From 2b4f450e4d5f3908d775edd34dd6722215d5cd7b Mon Sep 17 00:00:00 2001
From: Michael Schellenberger Costa <miscco@nvidia.com>
Date: Tue, 13 Sep 2022 21:02:27 +0200
Subject: [PATCH] Implement concept emulation for C++14 / C++17

This also ports all the standard concepts from libc++ preserving the new modular organization.
---
 .../equivalence_relation.compile.pass.cpp     |   63 +
 ...ence_relation.subsumption.compile.pass.cpp |   81 ++
 .../invocable.compile.pass.cpp                |  416 +++++++
 .../predicate.compile.pass.cpp                |   73 ++
 .../predicate.subsumption.compile.pass.cpp    |   31 +
 .../regular_invocable.compile.pass.cpp        |  474 +++++++
 .../relation.compile.pass.cpp                 |   61 +
 .../relation.subsumption.compile.pass.cpp     |   64 +
 .../strict_weak_order.compile.pass.cpp        |   62 +
 ...ct_weak_order.subsumption.compile.pass.cpp |   80 ++
 .../equality_comparable.compile.pass.cpp      |  135 ++
 .../equality_comparable_with.compile.pass.cpp | 1085 ++++++++++++++++
 .../totally_ordered.pass.cpp                  |  158 +++
 .../totally_ordered_with.pass.cpp             | 1109 +++++++++++++++++
 .../assignable_from.compile.pass.cpp          |  114 ++
 .../common_with.compile.pass.cpp              | 1021 +++++++++++++++
 .../common_reference.compile.pass.cpp         |  376 ++++++
 .../constructible_from.compile.pass.cpp       |  142 +++
 .../convertible_to.pass.cpp                   |  437 +++++++
 .../copy_constructible.compile.pass.cpp       |  179 +++
 .../default_initializable.compile.pass.cpp    |  196 +++
 .../default_initializable.verify.cpp          |   81 ++
 .../concept.derived/derived_from.pass.cpp     |  519 ++++++++
 .../destructible.compile.pass.cpp             |   80 ++
 .../move_constructible.compile.pass.cpp       |   83 ++
 .../concept.same/same_as.pass.cpp             |  305 +++++
 .../concept.swappable/swappable.pass.cpp      |  263 ++++
 .../swappable_with.compile.pass.cpp           |  797 ++++++++++++
 .../concepts.arithmetic/arithmetic.h          |   40 +
 .../floating_point.pass.cpp                   |   84 ++
 .../concepts.arithmetic/integral.pass.cpp     |  100 ++
 .../signed_integral.pass.cpp                  |  104 ++
 .../unsigned_integral.pass.cpp                |  105 ++
 .../concepts.object/copyable.compile.pass.cpp |   99 ++
 .../concepts.object/movable.compile.pass.cpp  |  122 ++
 .../concepts.object/regular.compile.pass.cpp  |  144 +++
 .../semiregular.compile.pass.cpp              |  108 ++
 .upstream-tests/test/support/compare_types.h  |  399 ++++++
 .../support/type_classification/copyable.h    |   78 ++
 .../support/type_classification/movable.h     |  159 +++
 .../type_classification/moveconstructible.h   |   75 ++
 .../support/type_classification/semiregular.h |   30 +
 .../support/type_classification/swappable.h   |  307 +++++
 include/cuda/std/concepts                     |   55 +
 include/cuda/std/detail/__concepts            |  278 +++++
 .../libcxx/include/__concepts/_One_of.h       |   35 +
 .../libcxx/include/__concepts/arithmetic.h    |   53 +
 .../libcxx/include/__concepts/assignable.h    |   60 +
 .../include/__concepts/boolean_testable.h     |   62 +
 .../libcxx/include/__concepts/class_or_enum.h |   38 +
 .../__concepts/common_reference_with.h        |   58 +
 .../libcxx/include/__concepts/common_with.h   |   93 ++
 .../libcxx/include/__concepts/constructible.h |   98 ++
 .../include/__concepts/convertible_to.h       |   52 +
 .../libcxx/include/__concepts/copyable.h      |   49 +
 .../libcxx/include/__concepts/derived_from.h  |   41 +
 .../libcxx/include/__concepts/destructible.h  |   35 +
 .../include/__concepts/different_from.h       |   36 +
 .../include/__concepts/equality_comparable.h  |  111 ++
 .../libcxx/include/__concepts/invocable.h     |   58 +
 .../libcxx/include/__concepts/movable.h       |   59 +
 .../libcxx/include/__concepts/predicate.h     |   51 +
 .../libcxx/include/__concepts/regular.h       |   39 +
 .../libcxx/include/__concepts/relation.h      |   49 +
 .../libcxx/include/__concepts/same_as.h       |   46 +
 .../libcxx/include/__concepts/semiregular.h   |   39 +
 .../libcxx/include/__concepts/swappable.h     |  225 ++++
 .../include/__concepts/totally_ordered.h      |  100 ++
 .../include/__type_traits/common_reference.h  |  188 +++
 .../libcxx/include/__type_traits/copy_cv.h    |   55 +
 .../libcxx/include/__type_traits/copy_cvref.h |   49 +
 .../std/detail/libcxx/include/type_traits     |    6 +
 .../cuda/std/detail/libcxx/include/utility    |    2 +-
 73 files changed, 12558 insertions(+), 1 deletion(-)
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered_with.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.common/common_with.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.commonref/common_reference.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.convertible/convertible_to.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.copyconstructible/copy_constructible.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.derived/derived_from.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.destructible/destructible.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.moveconstructible/move_constructible.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.same/same_as.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable_with.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/arithmetic.h
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/floating_point.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/integral.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.object/copyable.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.object/movable.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.object/regular.compile.pass.cpp
 create mode 100644 .upstream-tests/test/std/concepts/concepts.object/semiregular.compile.pass.cpp
 create mode 100644 .upstream-tests/test/support/compare_types.h
 create mode 100644 .upstream-tests/test/support/type_classification/copyable.h
 create mode 100644 .upstream-tests/test/support/type_classification/movable.h
 create mode 100644 .upstream-tests/test/support/type_classification/moveconstructible.h
 create mode 100644 .upstream-tests/test/support/type_classification/semiregular.h
 create mode 100644 .upstream-tests/test/support/type_classification/swappable.h
 create mode 100644 include/cuda/std/concepts
 create mode 100644 include/cuda/std/detail/__concepts
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/_One_of.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/arithmetic.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/assignable.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/boolean_testable.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/class_or_enum.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/common_reference_with.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/common_with.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/constructible.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/convertible_to.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/copyable.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/derived_from.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/destructible.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/different_from.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/equality_comparable.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/invocable.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/movable.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/predicate.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/regular.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/relation.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/same_as.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/semiregular.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/swappable.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__concepts/totally_ordered.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__type_traits/common_reference.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__type_traits/copy_cv.h
 create mode 100644 include/cuda/std/detail/libcxx/include/__type_traits/copy_cvref.h

diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.compile.pass.cpp
new file mode 100644
index 0000000000..74acc719de
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.compile.pass.cpp
@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class F, class... Args>
+// concept equivalence_relation;
+
+#include <cuda/std/concepts>
+
+using cuda::std::equivalence_relation;
+
+static_assert(equivalence_relation<bool(int, int), int, int>);
+static_assert(equivalence_relation<bool(int, int), double, double>);
+static_assert(equivalence_relation<bool(int, double), double, double>);
+
+static_assert(!equivalence_relation<bool (*)(), int, double>);
+static_assert(!equivalence_relation<bool (*)(int), int, double>);
+static_assert(!equivalence_relation<bool (*)(double), int, double>);
+
+static_assert(
+    !equivalence_relation<bool(double, double*), double, double*>);
+static_assert(!equivalence_relation<bool(int&, int&), double&, double&>);
+
+struct S1 {};
+static_assert(cuda::std::relation<bool (S1::*)(S1*), S1*, S1*>);
+static_assert(cuda::std::relation<bool (S1::*)(S1&), S1&, S1&>);
+
+struct S2 {};
+
+struct P1 {
+  bool operator()(S1, S1) const;
+};
+static_assert(equivalence_relation<P1, S1, S1>);
+
+struct P2 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+};
+static_assert(!equivalence_relation<P2, S1, S2>);
+
+struct P3 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+};
+static_assert(!equivalence_relation<P3, S1, S2>);
+
+struct P4 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(equivalence_relation<P4, S1, S2>);
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.compile.pass.cpp
new file mode 100644
index 0000000000..819894e990
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.equiv/equivalence_relation.subsumption.compile.pass.cpp
@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template<class F, class... Args>
+// concept equivalence_relation;
+
+#include <cuda/std/concepts>
+
+struct S1 {};
+struct S2 {};
+
+struct R {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+
+// clang-format off
+template<class F, class T, class U>
+requires cuda::std::relation<F, T, U>
+constexpr bool check_equivalence_relation_subsumes_relation() {
+  return false;
+}
+
+template<class F, class T, class U>
+requires cuda::std::equivalence_relation<F, T, U> && true
+constexpr bool check_equivalence_relation_subsumes_relation() {
+  return true;
+}
+// clang-format on
+
+static_assert(check_equivalence_relation_subsumes_relation<int (*)(int, int), int, int>());
+static_assert(check_equivalence_relation_subsumes_relation<int (*)(int, double), int, double>());
+static_assert(check_equivalence_relation_subsumes_relation<R, S1, S1>());
+static_assert(check_equivalence_relation_subsumes_relation<R, S1, S2>());
+
+// clang-format off
+template<class F, class T, class U>
+requires cuda::std::relation<F, T, U> && true
+constexpr bool check_relation_subsumes_equivalence_relation() {
+  return true;
+}
+
+template<class F, class T, class U>
+requires cuda::std::equivalence_relation<F, T, U>
+constexpr bool check_relation_subsumes_equivalence_relation() {
+  return false;
+}
+// clang-format on
+
+static_assert(check_relation_subsumes_equivalence_relation<int (*)(int, int), int, int>());
+static_assert(check_relation_subsumes_equivalence_relation<int (*)(int, double), int, double>());
+static_assert(check_relation_subsumes_equivalence_relation<R, S1, S1>());
+static_assert(check_relation_subsumes_equivalence_relation<R, S1, S2>());
+
+// clang-format off
+template<class F, class T, class U>
+requires cuda::std::equivalence_relation<F, T, T> && cuda::std::equivalence_relation<F, U, U>
+constexpr bool check_equivalence_relation_subsumes_itself() {
+  return false;
+}
+
+template<class F, class T, class U>
+requires cuda::std::equivalence_relation<F, T, U>
+constexpr bool check_equivalence_relation_subsumes_itself() {
+  return true;
+}
+// clang-format on
+
+static_assert(
+    check_equivalence_relation_subsumes_itself<int (*)(int, int), int, int>());
+static_assert(check_equivalence_relation_subsumes_itself<R, S1, S1>());
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.pass.cpp
new file mode 100644
index 0000000000..9e330d08cc
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.pass.cpp
@@ -0,0 +1,416 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T, class U>
+// concept invocable;
+
+#include <cuda/std/chrono>
+#include <cuda/std/concepts>
+#include <cuda/std/functional>
+#include <cuda/std/type_traits>
+
+using cuda::std::invocable;
+
+template <class R, class... Args>
+constexpr bool check_invocable() {
+  constexpr bool result = invocable<R(Args...), Args...>;
+  static_assert(invocable<R(Args...) noexcept, Args...> == result);
+  static_assert(invocable<R (*)(Args...), Args...> == result);
+  static_assert(invocable<R (*)(Args...) noexcept, Args...> == result);
+  static_assert(invocable<R (&)(Args...), Args...> == result);
+  static_assert(invocable<R (&)(Args...) noexcept, Args...> == result);
+
+  return result;
+}
+
+static_assert(check_invocable<void>());
+static_assert(check_invocable<void, int>());
+static_assert(check_invocable<void, int&>());
+static_assert(check_invocable<void, int*, double>());
+static_assert(check_invocable<int>());
+static_assert(check_invocable<int, int[]>());
+
+struct S;
+static_assert(check_invocable<int, int S::*, std::nullptr_t>());
+static_assert(check_invocable<int, int (S::*)(), int (S::*)(int), int>());
+static_assert(invocable<void (*)(int const&), int&>);
+static_assert(invocable<void (*)(int const&), int&&>);
+static_assert(invocable<void (*)(int volatile&), int&>);
+static_assert(invocable<void (*)(int const volatile&), int&>);
+
+static_assert(!invocable<void(), int>);
+static_assert(!invocable<void(int)>);
+static_assert(!invocable<void(int*), double*>);
+static_assert(!invocable<void (*)(int&), double*>);
+static_assert(!invocable<void (*)(int&&), int&>);
+static_assert(!invocable<void (*)(int&&), int const&>);
+
+static_assert(!invocable<void>);
+static_assert(!invocable<void*>);
+static_assert(!invocable<int>);
+static_assert(!invocable<int&>);
+static_assert(!invocable<int&&>);
+
+namespace function_objects {
+struct function_object {
+  void operator()();
+};
+static_assert(invocable<function_object>);
+static_assert(!invocable<function_object const>);
+static_assert(!invocable<function_object volatile>);
+static_assert(!invocable<function_object const volatile>);
+static_assert(invocable<function_object&>);
+static_assert(!invocable<function_object const&>);
+static_assert(!invocable<function_object volatile&>);
+static_assert(!invocable<function_object const volatile&>);
+
+struct const_function_object {
+  void operator()(int) const;
+};
+static_assert(invocable<const_function_object, int>);
+static_assert(invocable<const_function_object const, int>);
+static_assert(!invocable<const_function_object volatile, int>);
+static_assert(!invocable<const_function_object const volatile, int>);
+static_assert(invocable<const_function_object&, int>);
+static_assert(invocable<const_function_object const&, int>);
+static_assert(!invocable<const_function_object volatile&, int>);
+static_assert(!invocable<const_function_object const volatile&, int>);
+
+struct volatile_function_object {
+  void operator()(int, int) volatile;
+};
+static_assert(invocable<volatile_function_object, int, int>);
+static_assert(!invocable<volatile_function_object const, int, int>);
+static_assert(invocable<volatile_function_object volatile, int, int>);
+static_assert(
+    !invocable<volatile_function_object const volatile, int, int>);
+static_assert(invocable<volatile_function_object&, int, int>);
+static_assert(!invocable<volatile_function_object const&, int, int>);
+static_assert(invocable<volatile_function_object volatile&, int, int>);
+static_assert(
+    !invocable<volatile_function_object const volatile&, int, int>);
+
+struct cv_function_object {
+  void operator()(int[]) const volatile;
+};
+static_assert(invocable<cv_function_object, int*>);
+static_assert(invocable<cv_function_object const, int*>);
+static_assert(invocable<cv_function_object volatile, int*>);
+static_assert(invocable<cv_function_object const volatile, int*>);
+static_assert(invocable<cv_function_object&, int*>);
+static_assert(invocable<cv_function_object const&, int*>);
+static_assert(invocable<cv_function_object volatile&, int*>);
+static_assert(invocable<cv_function_object const volatile&, int*>);
+
+struct lvalue_function_object {
+  void operator()() &;
+};
+static_assert(!invocable<lvalue_function_object>);
+static_assert(!invocable<lvalue_function_object const>);
+static_assert(!invocable<lvalue_function_object volatile>);
+static_assert(!invocable<lvalue_function_object const volatile>);
+static_assert(invocable<lvalue_function_object&>);
+static_assert(!invocable<lvalue_function_object const&>);
+static_assert(!invocable<lvalue_function_object volatile&>);
+static_assert(!invocable<lvalue_function_object const volatile&>);
+
+struct lvalue_const_function_object {
+  void operator()(int) const&;
+};
+static_assert(invocable<lvalue_const_function_object, int>);
+static_assert(invocable<lvalue_const_function_object const, int>);
+static_assert(!invocable<lvalue_const_function_object volatile, int>);
+static_assert(
+    !invocable<lvalue_const_function_object const volatile, int>);
+static_assert(invocable<lvalue_const_function_object&, int>);
+static_assert(invocable<lvalue_const_function_object const&, int>);
+static_assert(!invocable<lvalue_const_function_object volatile&, int>);
+static_assert(
+    !invocable<lvalue_const_function_object const volatile&, int>);
+
+struct lvalue_volatile_function_object {
+  void operator()(int, int) volatile&;
+};
+static_assert(!invocable<lvalue_volatile_function_object, int, int>);
+static_assert(!invocable<lvalue_volatile_function_object const, int, int>);
+static_assert(
+    !invocable<lvalue_volatile_function_object volatile, int, int>);
+static_assert(
+    !invocable<lvalue_volatile_function_object const volatile, int, int>);
+static_assert(invocable<lvalue_volatile_function_object&, int, int>);
+static_assert(
+    !invocable<lvalue_volatile_function_object const&, int, int>);
+static_assert(
+    invocable<lvalue_volatile_function_object volatile&, int, int>);
+static_assert(
+    !invocable<lvalue_volatile_function_object const volatile&, int, int>);
+
+struct lvalue_cv_function_object {
+  void operator()(int[]) const volatile&;
+};
+static_assert(!invocable<lvalue_cv_function_object, int*>);
+static_assert(!invocable<lvalue_cv_function_object const, int*>);
+static_assert(!invocable<lvalue_cv_function_object volatile, int*>);
+static_assert(!invocable<lvalue_cv_function_object const volatile, int*>);
+static_assert(invocable<lvalue_cv_function_object&, int*>);
+static_assert(invocable<lvalue_cv_function_object const&, int*>);
+static_assert(invocable<lvalue_cv_function_object volatile&, int*>);
+static_assert(invocable<lvalue_cv_function_object const volatile&, int*>);
+//
+struct rvalue_function_object {
+  void operator()() &&;
+};
+static_assert(invocable<rvalue_function_object>);
+static_assert(!invocable<rvalue_function_object const>);
+static_assert(!invocable<rvalue_function_object volatile>);
+static_assert(!invocable<rvalue_function_object const volatile>);
+static_assert(!invocable<rvalue_function_object&>);
+static_assert(!invocable<rvalue_function_object const&>);
+static_assert(!invocable<rvalue_function_object volatile&>);
+static_assert(!invocable<rvalue_function_object const volatile&>);
+
+struct rvalue_const_function_object {
+  void operator()(int) const&&;
+};
+static_assert(invocable<rvalue_const_function_object, int>);
+static_assert(invocable<rvalue_const_function_object const, int>);
+static_assert(!invocable<rvalue_const_function_object volatile, int>);
+static_assert(
+    !invocable<rvalue_const_function_object const volatile, int>);
+static_assert(!invocable<rvalue_const_function_object&, int>);
+static_assert(!invocable<rvalue_const_function_object const&, int>);
+static_assert(!invocable<rvalue_const_function_object volatile&, int>);
+static_assert(
+    !invocable<rvalue_const_function_object const volatile&, int>);
+
+struct rvalue_volatile_function_object {
+  void operator()(int, int) volatile&&;
+};
+static_assert(invocable<rvalue_volatile_function_object, int, int>);
+static_assert(!invocable<rvalue_volatile_function_object const, int, int>);
+static_assert(
+    invocable<rvalue_volatile_function_object volatile, int, int>);
+static_assert(
+    !invocable<rvalue_volatile_function_object const volatile, int, int>);
+static_assert(!invocable<rvalue_volatile_function_object&, int, int>);
+static_assert(
+    !invocable<rvalue_volatile_function_object const&, int, int>);
+static_assert(
+    !invocable<rvalue_volatile_function_object volatile&, int, int>);
+static_assert(
+    !invocable<rvalue_volatile_function_object const volatile&, int, int>);
+
+struct rvalue_cv_function_object {
+  void operator()(int[]) const volatile&&;
+};
+static_assert(invocable<rvalue_cv_function_object, int*>);
+static_assert(invocable<rvalue_cv_function_object const, int*>);
+static_assert(invocable<rvalue_cv_function_object volatile, int*>);
+static_assert(invocable<rvalue_cv_function_object const volatile, int*>);
+static_assert(!invocable<rvalue_cv_function_object&, int*>);
+static_assert(!invocable<rvalue_cv_function_object const&, int*>);
+static_assert(!invocable<rvalue_cv_function_object volatile&, int*>);
+static_assert(!invocable<rvalue_cv_function_object const volatile&, int*>);
+
+struct multiple_overloads {
+  struct A {};
+  struct B { B(int); };
+  struct AB : A, B {};
+  struct O {};
+  void operator()(A) const;
+  void operator()(B) const;
+};
+static_assert(invocable<multiple_overloads, multiple_overloads::A>);
+static_assert(invocable<multiple_overloads, multiple_overloads::B>);
+static_assert(invocable<multiple_overloads, int>);
+static_assert(!invocable<multiple_overloads, multiple_overloads::AB>);
+static_assert(!invocable<multiple_overloads, multiple_overloads::O>);
+} // namespace function_objects
+
+namespace pointer_to_member_functions {
+  template<class Member, class T, class... Args>
+  constexpr bool check_member_is_invocable()
+  {
+    constexpr bool result = invocable<Member, T&&, Args...>;
+    using uncv_t = cuda::std::remove_cvref_t<T>;
+    static_assert(invocable<Member, uncv_t*, Args...> == result);
+    static_assert(invocable<Member, cuda::std::reference_wrapper<uncv_t>, Args...> == result);
+    static_assert(!invocable<Member, cuda::std::nullptr_t, Args...>);
+    static_assert(!invocable<Member, int, Args...>);
+    static_assert(!invocable<Member, int*, Args...>);
+    static_assert(!invocable<Member, double*, Args...>);
+    struct S2 {};
+    static_assert(!invocable<Member, S2*, Args...>);
+    return result;
+  }
+
+static_assert(check_member_is_invocable<int S::*, S>());
+static_assert(invocable<int S::*, S&>);
+static_assert(invocable<int S::*, S const&>);
+static_assert(invocable<int S::*, S volatile&>);
+static_assert(invocable<int S::*, S const volatile&>);
+static_assert(invocable<int S::*, S&&>);
+static_assert(invocable<int S::*, S const&&>);
+static_assert(invocable<int S::*, S volatile&&>);
+static_assert(invocable<int S::*, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)(int), S, int>());
+static_assert(!check_member_is_invocable<int (S::*)(int), S>());
+using unqualified = void (S::*)();
+static_assert(invocable<unqualified, S&>);
+static_assert(!invocable<unqualified, S const&>);
+static_assert(!invocable<unqualified, S volatile&>);
+static_assert(!invocable<unqualified, S const volatile&>);
+static_assert(invocable<unqualified, S&&>);
+static_assert(!invocable<unqualified, S const&&>);
+static_assert(!invocable<unqualified, S volatile&&>);
+static_assert(!invocable<unqualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)(double) const, S, double>());
+using const_qualified = void (S::*)() const;
+static_assert(invocable<const_qualified, S&>);
+static_assert(invocable<const_qualified, S const&>);
+static_assert(!invocable<const_qualified, S volatile&>);
+static_assert(!invocable<const_qualified, S const volatile&>);
+static_assert(invocable<const_qualified, S&&>);
+static_assert(invocable<const_qualified, S const&&>);
+static_assert(!invocable<const_qualified, S volatile&&>);
+static_assert(!invocable<const_qualified, S const volatile&&>);
+
+static_assert(
+    check_member_is_invocable<int (S::*)(double[]) volatile, S, double*>());
+using volatile_qualified = void (S::*)() volatile;
+static_assert(invocable<volatile_qualified, S&>);
+static_assert(!invocable<volatile_qualified, S const&>);
+static_assert(invocable<volatile_qualified, S volatile&>);
+static_assert(!invocable<volatile_qualified, S const volatile&>);
+static_assert(invocable<volatile_qualified, S&&>);
+static_assert(!invocable<volatile_qualified, S const&&>);
+static_assert(invocable<volatile_qualified, S volatile&&>);
+static_assert(!invocable<volatile_qualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)(int, S&) const volatile, S,
+                                        int, S&>());
+using cv_qualified = void (S::*)() const volatile;
+static_assert(invocable<cv_qualified, S&>);
+static_assert(invocable<cv_qualified, S const&>);
+static_assert(invocable<cv_qualified, S volatile&>);
+static_assert(invocable<cv_qualified, S const volatile&>);
+static_assert(invocable<cv_qualified, S&&>);
+static_assert(invocable<cv_qualified, S const&&>);
+static_assert(invocable<cv_qualified, S volatile&&>);
+static_assert(invocable<cv_qualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)() &, S&>());
+using lvalue_qualified = void (S::*)() &;
+static_assert(invocable<lvalue_qualified, S&>);
+static_assert(!invocable<lvalue_qualified, S const&>);
+static_assert(!invocable<lvalue_qualified, S volatile&>);
+static_assert(!invocable<lvalue_qualified, S const volatile&>);
+static_assert(!invocable<lvalue_qualified, S&&>);
+static_assert(!invocable<lvalue_qualified, S const&&>);
+static_assert(!invocable<lvalue_qualified, S volatile&&>);
+static_assert(!invocable<lvalue_qualified, S const volatile&&>);
+
+#if TEST_STD_VER > 17
+static_assert(check_member_is_invocable<int (S::*)() const&, S>());
+#endif // TEST_STD_VER > 17
+using lvalue_const_qualified = void (S::*)() const&;
+static_assert(invocable<lvalue_const_qualified, S&>);
+static_assert(invocable<lvalue_const_qualified, S const&>);
+static_assert(!invocable<lvalue_const_qualified, S volatile&>);
+static_assert(!invocable<lvalue_const_qualified, S const volatile&>);
+#if TEST_STD_VER > 17
+static_assert(invocable<lvalue_const_qualified, S&&>);
+static_assert(invocable<lvalue_const_qualified, S const&&>);
+#endif // TEST_STD_VER > 17
+static_assert(!invocable<lvalue_const_qualified, S volatile&&>);
+static_assert(!invocable<lvalue_const_qualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)() volatile&, S&>());
+using lvalue_volatile_qualified = void (S::*)() volatile&;
+static_assert(invocable<lvalue_volatile_qualified, S&>);
+static_assert(!invocable<lvalue_volatile_qualified, S const&>);
+static_assert(invocable<lvalue_volatile_qualified, S volatile&>);
+static_assert(!invocable<lvalue_volatile_qualified, S const volatile&>);
+static_assert(!invocable<lvalue_volatile_qualified, S&&>);
+static_assert(!invocable<lvalue_volatile_qualified, S const&&>);
+static_assert(!invocable<lvalue_volatile_qualified, S volatile&&>);
+static_assert(!invocable<lvalue_volatile_qualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)() const volatile&, S&>());
+using lvalue_cv_qualified = void (S::*)() const volatile&;
+static_assert(invocable<lvalue_cv_qualified, S&>);
+static_assert(invocable<lvalue_cv_qualified, S const&>);
+static_assert(invocable<lvalue_cv_qualified, S volatile&>);
+static_assert(invocable<lvalue_cv_qualified, S const volatile&>);
+static_assert(!invocable<lvalue_cv_qualified, S&&>);
+static_assert(!invocable<lvalue_cv_qualified, S const&&>);
+static_assert(!invocable<lvalue_cv_qualified, S volatile&&>);
+static_assert(!invocable<lvalue_cv_qualified, S const volatile&&>);
+
+using rvalue_unqualified = void (S::*)() &&;
+static_assert(!invocable<rvalue_unqualified, S&>);
+static_assert(!invocable<rvalue_unqualified, S const&>);
+static_assert(!invocable<rvalue_unqualified, S volatile&>);
+static_assert(!invocable<rvalue_unqualified, S const volatile&>);
+static_assert(invocable<rvalue_unqualified, S&&>);
+static_assert(!invocable<rvalue_unqualified, S const&&>);
+static_assert(!invocable<rvalue_unqualified, S volatile&&>);
+static_assert(!invocable<rvalue_unqualified, S const volatile&&>);
+
+using rvalue_const_unqualified = void (S::*)() const&&;
+static_assert(!invocable<rvalue_const_unqualified, S&>);
+static_assert(!invocable<rvalue_const_unqualified, S const&>);
+static_assert(!invocable<rvalue_const_unqualified, S volatile&>);
+static_assert(!invocable<rvalue_const_unqualified, S const volatile&>);
+static_assert(invocable<rvalue_const_unqualified, S&&>);
+static_assert(invocable<rvalue_const_unqualified, S const&&>);
+static_assert(!invocable<rvalue_const_unqualified, S volatile&&>);
+static_assert(!invocable<rvalue_const_unqualified, S const volatile&&>);
+
+using rvalue_volatile_unqualified = void (S::*)() volatile&&;
+static_assert(!invocable<rvalue_volatile_unqualified, S&>);
+static_assert(!invocable<rvalue_volatile_unqualified, S const&>);
+static_assert(!invocable<rvalue_volatile_unqualified, S volatile&>);
+static_assert(!invocable<rvalue_volatile_unqualified, S const volatile&>);
+static_assert(invocable<rvalue_volatile_unqualified, S&&>);
+static_assert(!invocable<rvalue_volatile_unqualified, S const&&>);
+static_assert(invocable<rvalue_volatile_unqualified, S volatile&&>);
+static_assert(!invocable<rvalue_volatile_unqualified, S const volatile&&>);
+
+using rvalue_cv_unqualified = void (S::*)() const volatile&&;
+static_assert(!invocable<rvalue_cv_unqualified, S&>);
+static_assert(!invocable<rvalue_cv_unqualified, S const&>);
+static_assert(!invocable<rvalue_cv_unqualified, S volatile&>);
+static_assert(!invocable<rvalue_cv_unqualified, S const volatile&>);
+static_assert(invocable<rvalue_cv_unqualified, S&&>);
+static_assert(invocable<rvalue_cv_unqualified, S const&&>);
+static_assert(invocable<rvalue_cv_unqualified, S volatile&&>);
+static_assert(invocable<rvalue_cv_unqualified, S const volatile&&>);
+} // namespace pointer_to_member_functions
+
+// Check the concept with closure types
+template<class F, class... Args>
+constexpr bool is_invocable(F, Args&&...) {
+  return invocable<F, Args...>;
+}
+
+#if TEST_STD_VER > 14
+static_assert(is_invocable([] {}));
+static_assert(is_invocable([](int) {}, 0));
+static_assert(is_invocable([](int) {}, 0L));
+static_assert(!is_invocable([](int) {}, nullptr));
+int i = 0;
+static_assert(is_invocable([](int&) {}, i));
+#endif // TEST_STD_VER > 14
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.compile.pass.cpp
new file mode 100644
index 0000000000..ecd9f9eee8
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.compile.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class F, class... Args>
+// concept predicate;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+using cuda::std::predicate;
+
+static_assert(predicate<bool()>);
+static_assert(predicate<bool (*)()>);
+static_assert(predicate<bool (&)()>);
+
+static_assert(!predicate<void()>);
+static_assert(!predicate<void (*)()>);
+static_assert(!predicate<void (&)()>);
+
+struct S {};
+
+static_assert(!predicate<S(int), int>);
+static_assert(!predicate<S(double), double>);
+static_assert(predicate<int S::*, S*>);
+static_assert(predicate<int (S::*)(), S*>);
+static_assert(predicate<int (S::*)(), S&>);
+static_assert(!predicate<void (S::*)(), S*>);
+static_assert(!predicate<void (S::*)(), S&>);
+
+static_assert(!predicate<bool(S)>);
+static_assert(!predicate<bool(S)>);
+static_assert(!predicate<bool(S&), S>);
+static_assert(!predicate<bool(S&), S const&>);
+static_assert(predicate<bool(S&), S&>);
+
+struct Predicate {
+  bool operator()(int, double, char);
+};
+static_assert(predicate<Predicate, int, double, char>);
+static_assert(predicate<Predicate&, int, double, char>);
+static_assert(!predicate<const Predicate, int, double, char>);
+static_assert(!predicate<const Predicate&, int, double, char>);
+
+#if TEST_STD_VER > 17
+constexpr bool check_lambda(auto) { return false; }
+
+constexpr bool check_lambda(predicate auto) { return true; }
+#endif // TEST_STD_VER > 17
+
+#if TEST_STD_VER > 14
+static_assert(check_lambda([] { return std::true_type(); }));
+static_assert(check_lambda([]() -> int* { return nullptr; }));
+
+struct boolean {
+  operator bool() const noexcept;
+};
+static_assert(check_lambda([] { return boolean(); }));
+
+struct explicit_bool {
+  explicit operator bool() const noexcept;
+};
+static_assert(!check_lambda([] { return explicit_bool(); }));
+#endif // TEST_STD_VER > 14
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.compile.pass.cpp
new file mode 100644
index 0000000000..621013ea6b
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.predicate/predicate.subsumption.compile.pass.cpp
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template<class F, class... Args>
+// concept predicate;
+
+#include <cuda/std/concepts>
+
+constexpr bool check_subsumption(cuda::std::regular_invocable auto) {
+  return false;
+}
+
+// clang-format off
+template<class F>
+requires cuda::std::predicate<F> && true
+constexpr bool check_subsumption(F)
+{
+  return true;
+}
+// clang-format on
+
+static_assert(!check_subsumption([] {}));
+static_assert(check_subsumption([] { return true; }));
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.compile.pass.cpp
new file mode 100644
index 0000000000..40d0d0c6b6
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.compile.pass.cpp
@@ -0,0 +1,474 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T, class U>
+// concept regular_invocable;
+
+#include <cuda/std/chrono>
+#include <cuda/std/concepts>
+#include <cuda/std/functional>
+#include <cuda/std/type_traits>
+
+using cuda::std::regular_invocable;
+
+template <class R, class... Args>
+constexpr bool check_invocable() {
+  constexpr bool result = regular_invocable<R(Args...), Args...>;
+  static_assert(regular_invocable<R(Args...) noexcept, Args...> == result);
+  static_assert(regular_invocable<R (*)(Args...), Args...> == result);
+  static_assert(regular_invocable<R (*)(Args...) noexcept, Args...> ==
+                result);
+  static_assert(regular_invocable<R (&)(Args...), Args...> == result);
+  static_assert(regular_invocable<R (&)(Args...) noexcept, Args...> ==
+                result);
+
+  return result;
+}
+
+static_assert(check_invocable<void>());
+static_assert(check_invocable<void, int>());
+static_assert(check_invocable<void, int&>());
+static_assert(check_invocable<void, int*, double>());
+static_assert(check_invocable<int>());
+static_assert(check_invocable<int, int[]>());
+
+struct S;
+static_assert(check_invocable<int, int S::*, std::nullptr_t>());
+static_assert(check_invocable<int, int (S::*)(), int (S::*)(int), int>());
+static_assert(regular_invocable<void (*)(int const&), int&>);
+static_assert(regular_invocable<void (*)(int const&), int&&>);
+static_assert(regular_invocable<void (*)(int volatile&), int&>);
+static_assert(regular_invocable<void (*)(int const volatile&), int&>);
+
+static_assert(!regular_invocable<void(), int>);
+static_assert(!regular_invocable<void(int)>);
+static_assert(!regular_invocable<void(int*), double*>);
+static_assert(!regular_invocable<void (*)(int&), double*>);
+static_assert(!regular_invocable<void (*)(int&&), int&>);
+static_assert(!regular_invocable<void (*)(int&&), int const&>);
+
+static_assert(!regular_invocable<void>);
+static_assert(!regular_invocable<void*>);
+static_assert(!regular_invocable<int>);
+static_assert(!regular_invocable<int&>);
+static_assert(!regular_invocable<int&&>);
+
+namespace function_objects {
+struct function_object {
+  void operator()();
+};
+static_assert(regular_invocable<function_object>);
+static_assert(!regular_invocable<function_object const>);
+static_assert(!regular_invocable<function_object volatile>);
+static_assert(!regular_invocable<function_object const volatile>);
+static_assert(regular_invocable<function_object&>);
+static_assert(!regular_invocable<function_object const&>);
+static_assert(!regular_invocable<function_object volatile&>);
+static_assert(!regular_invocable<function_object const volatile&>);
+
+struct const_function_object {
+  void operator()(int) const;
+};
+static_assert(regular_invocable<const_function_object, int>);
+static_assert(regular_invocable<const_function_object const, int>);
+static_assert(!regular_invocable<const_function_object volatile, int>);
+static_assert(
+    !regular_invocable<const_function_object const volatile, int>);
+static_assert(regular_invocable<const_function_object&, int>);
+static_assert(regular_invocable<const_function_object const&, int>);
+static_assert(!regular_invocable<const_function_object volatile&, int>);
+static_assert(
+    !regular_invocable<const_function_object const volatile&, int>);
+
+struct volatile_function_object {
+  void operator()(int, int) volatile;
+};
+static_assert(regular_invocable<volatile_function_object, int, int>);
+static_assert(
+    !regular_invocable<volatile_function_object const, int, int>);
+static_assert(
+    regular_invocable<volatile_function_object volatile, int, int>);
+static_assert(
+    !regular_invocable<volatile_function_object const volatile, int, int>);
+static_assert(regular_invocable<volatile_function_object&, int, int>);
+static_assert(
+    !regular_invocable<volatile_function_object const&, int, int>);
+static_assert(
+    regular_invocable<volatile_function_object volatile&, int, int>);
+static_assert(!regular_invocable<volatile_function_object const volatile&,
+                                      int, int>);
+
+struct cv_function_object {
+  void operator()(int[]) const volatile;
+};
+static_assert(regular_invocable<cv_function_object, int*>);
+static_assert(regular_invocable<cv_function_object const, int*>);
+static_assert(regular_invocable<cv_function_object volatile, int*>);
+static_assert(regular_invocable<cv_function_object const volatile, int*>);
+static_assert(regular_invocable<cv_function_object&, int*>);
+static_assert(regular_invocable<cv_function_object const&, int*>);
+static_assert(regular_invocable<cv_function_object volatile&, int*>);
+static_assert(regular_invocable<cv_function_object const volatile&, int*>);
+
+struct lvalue_function_object {
+  void operator()() &;
+};
+static_assert(!regular_invocable<lvalue_function_object>);
+static_assert(!regular_invocable<lvalue_function_object const>);
+static_assert(!regular_invocable<lvalue_function_object volatile>);
+static_assert(!regular_invocable<lvalue_function_object const volatile>);
+static_assert(regular_invocable<lvalue_function_object&>);
+static_assert(!regular_invocable<lvalue_function_object const&>);
+static_assert(!regular_invocable<lvalue_function_object volatile&>);
+static_assert(!regular_invocable<lvalue_function_object const volatile&>);
+
+struct lvalue_const_function_object {
+  void operator()(int) const&;
+};
+static_assert(regular_invocable<lvalue_const_function_object, int>);
+static_assert(regular_invocable<lvalue_const_function_object const, int>);
+static_assert(
+    !regular_invocable<lvalue_const_function_object volatile, int>);
+static_assert(
+    !regular_invocable<lvalue_const_function_object const volatile, int>);
+static_assert(regular_invocable<lvalue_const_function_object&, int>);
+static_assert(regular_invocable<lvalue_const_function_object const&, int>);
+static_assert(
+    !regular_invocable<lvalue_const_function_object volatile&, int>);
+static_assert(
+    !regular_invocable<lvalue_const_function_object const volatile&, int>);
+
+struct lvalue_volatile_function_object {
+  void operator()(int, int) volatile&;
+};
+static_assert(
+    !regular_invocable<lvalue_volatile_function_object, int, int>);
+static_assert(
+    !regular_invocable<lvalue_volatile_function_object const, int, int>);
+static_assert(!regular_invocable<lvalue_volatile_function_object volatile,
+                                      int, int>);
+static_assert(!regular_invocable<
+              lvalue_volatile_function_object const volatile, int, int>);
+static_assert(
+    regular_invocable<lvalue_volatile_function_object&, int, int>);
+static_assert(
+    !regular_invocable<lvalue_volatile_function_object const&, int, int>);
+static_assert(regular_invocable<lvalue_volatile_function_object volatile&,
+                                     int, int>);
+static_assert(!regular_invocable<
+              lvalue_volatile_function_object const volatile&, int, int>);
+
+struct lvalue_cv_function_object {
+  void operator()(int[]) const volatile&;
+};
+static_assert(!regular_invocable<lvalue_cv_function_object, int*>);
+static_assert(!regular_invocable<lvalue_cv_function_object const, int*>);
+static_assert(
+    !regular_invocable<lvalue_cv_function_object volatile, int*>);
+static_assert(
+    !regular_invocable<lvalue_cv_function_object const volatile, int*>);
+static_assert(regular_invocable<lvalue_cv_function_object&, int*>);
+static_assert(regular_invocable<lvalue_cv_function_object const&, int*>);
+static_assert(
+    regular_invocable<lvalue_cv_function_object volatile&, int*>);
+static_assert(
+    regular_invocable<lvalue_cv_function_object const volatile&, int*>);
+//
+struct rvalue_function_object {
+  void operator()() &&;
+};
+static_assert(regular_invocable<rvalue_function_object>);
+static_assert(!regular_invocable<rvalue_function_object const>);
+static_assert(!regular_invocable<rvalue_function_object volatile>);
+static_assert(!regular_invocable<rvalue_function_object const volatile>);
+static_assert(!regular_invocable<rvalue_function_object&>);
+static_assert(!regular_invocable<rvalue_function_object const&>);
+static_assert(!regular_invocable<rvalue_function_object volatile&>);
+static_assert(!regular_invocable<rvalue_function_object const volatile&>);
+
+struct rvalue_const_function_object {
+  void operator()(int) const&&;
+};
+static_assert(regular_invocable<rvalue_const_function_object, int>);
+static_assert(regular_invocable<rvalue_const_function_object const, int>);
+static_assert(
+    !regular_invocable<rvalue_const_function_object volatile, int>);
+static_assert(
+    !regular_invocable<rvalue_const_function_object const volatile, int>);
+static_assert(!regular_invocable<rvalue_const_function_object&, int>);
+static_assert(
+    !regular_invocable<rvalue_const_function_object const&, int>);
+static_assert(
+    !regular_invocable<rvalue_const_function_object volatile&, int>);
+static_assert(
+    !regular_invocable<rvalue_const_function_object const volatile&, int>);
+
+struct rvalue_volatile_function_object {
+  void operator()(int, int) volatile&&;
+};
+static_assert(
+    regular_invocable<rvalue_volatile_function_object, int, int>);
+static_assert(
+    !regular_invocable<rvalue_volatile_function_object const, int, int>);
+static_assert(
+    regular_invocable<rvalue_volatile_function_object volatile, int, int>);
+static_assert(!regular_invocable<
+              rvalue_volatile_function_object const volatile, int, int>);
+static_assert(
+    !regular_invocable<rvalue_volatile_function_object&, int, int>);
+static_assert(
+    !regular_invocable<rvalue_volatile_function_object const&, int, int>);
+static_assert(!regular_invocable<rvalue_volatile_function_object volatile&,
+                                      int, int>);
+static_assert(!regular_invocable<
+              rvalue_volatile_function_object const volatile&, int, int>);
+
+struct rvalue_cv_function_object {
+  void operator()(int[]) const volatile&&;
+};
+static_assert(regular_invocable<rvalue_cv_function_object, int*>);
+static_assert(regular_invocable<rvalue_cv_function_object const, int*>);
+static_assert(regular_invocable<rvalue_cv_function_object volatile, int*>);
+static_assert(
+    regular_invocable<rvalue_cv_function_object const volatile, int*>);
+static_assert(!regular_invocable<rvalue_cv_function_object&, int*>);
+static_assert(!regular_invocable<rvalue_cv_function_object const&, int*>);
+static_assert(
+    !regular_invocable<rvalue_cv_function_object volatile&, int*>);
+static_assert(
+    !regular_invocable<rvalue_cv_function_object const volatile&, int*>);
+
+struct multiple_overloads {
+  struct A {};
+  struct B { B(int); };
+  struct AB : A, B {};
+  struct O {};
+  void operator()(A) const;
+  void operator()(B) const;
+};
+static_assert(regular_invocable<multiple_overloads, multiple_overloads::A>);
+static_assert(regular_invocable<multiple_overloads, multiple_overloads::B>);
+static_assert(regular_invocable<multiple_overloads, int>);
+static_assert(!regular_invocable<multiple_overloads, multiple_overloads::AB>);
+static_assert(!regular_invocable<multiple_overloads, multiple_overloads::O>);
+} // namespace function_objects
+
+namespace pointer_to_member_functions {
+  template<class Member, class T, class... Args>
+  constexpr bool check_member_is_invocable()
+  {
+    constexpr bool result = regular_invocable<Member, T&&, Args...>;
+    using uncv_t = cuda::std::remove_cvref_t<T>;
+    static_assert(regular_invocable<Member, uncv_t*, Args...> == result);
+    static_assert(regular_invocable<Member, cuda::std::reference_wrapper<uncv_t>, Args...> == result);
+    static_assert(!regular_invocable<Member, cuda::std::nullptr_t, Args...>);
+    static_assert(!regular_invocable<Member, int, Args...>);
+    static_assert(!regular_invocable<Member, int*, Args...>);
+    static_assert(!regular_invocable<Member, double*, Args...>);
+    struct S2 {};
+    static_assert(!regular_invocable<Member, S2*, Args...>);
+    return result;
+  }
+
+static_assert(check_member_is_invocable<int S::*, S>());
+static_assert(regular_invocable<int S::*, S&>);
+static_assert(regular_invocable<int S::*, S const&>);
+static_assert(regular_invocable<int S::*, S volatile&>);
+static_assert(regular_invocable<int S::*, S const volatile&>);
+static_assert(regular_invocable<int S::*, S&&>);
+static_assert(regular_invocable<int S::*, S const&&>);
+static_assert(regular_invocable<int S::*, S volatile&&>);
+static_assert(regular_invocable<int S::*, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)(int), S, int>());
+static_assert(!check_member_is_invocable<int (S::*)(int), S>());
+using unqualified = void (S::*)();
+static_assert(regular_invocable<unqualified, S&>);
+static_assert(!regular_invocable<unqualified, S const&>);
+static_assert(!regular_invocable<unqualified, S volatile&>);
+static_assert(!regular_invocable<unqualified, S const volatile&>);
+static_assert(regular_invocable<unqualified, S&&>);
+static_assert(!regular_invocable<unqualified, S const&&>);
+static_assert(!regular_invocable<unqualified, S volatile&&>);
+static_assert(!regular_invocable<unqualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)(double) const, S, double>());
+using const_qualified = void (S::*)() const;
+static_assert(regular_invocable<const_qualified, S&>);
+static_assert(regular_invocable<const_qualified, S const&>);
+static_assert(!regular_invocable<const_qualified, S volatile&>);
+static_assert(!regular_invocable<const_qualified, S const volatile&>);
+static_assert(regular_invocable<const_qualified, S&&>);
+static_assert(regular_invocable<const_qualified, S const&&>);
+static_assert(!regular_invocable<const_qualified, S volatile&&>);
+static_assert(!regular_invocable<const_qualified, S const volatile&&>);
+
+static_assert(
+    check_member_is_invocable<int (S::*)(double[]) volatile, S, double*>());
+using volatile_qualified = void (S::*)() volatile;
+static_assert(regular_invocable<volatile_qualified, S&>);
+static_assert(!regular_invocable<volatile_qualified, S const&>);
+static_assert(regular_invocable<volatile_qualified, S volatile&>);
+static_assert(!regular_invocable<volatile_qualified, S const volatile&>);
+static_assert(regular_invocable<volatile_qualified, S&&>);
+static_assert(!regular_invocable<volatile_qualified, S const&&>);
+static_assert(regular_invocable<volatile_qualified, S volatile&&>);
+static_assert(!regular_invocable<volatile_qualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)(int, S&) const volatile, S,
+                                        int, S&>());
+using cv_qualified = void (S::*)() const volatile;
+static_assert(regular_invocable<cv_qualified, S&>);
+static_assert(regular_invocable<cv_qualified, S const&>);
+static_assert(regular_invocable<cv_qualified, S volatile&>);
+static_assert(regular_invocable<cv_qualified, S const volatile&>);
+static_assert(regular_invocable<cv_qualified, S&&>);
+static_assert(regular_invocable<cv_qualified, S const&&>);
+static_assert(regular_invocable<cv_qualified, S volatile&&>);
+static_assert(regular_invocable<cv_qualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)() &, S&>());
+using lvalue_qualified = void (S::*)() &;
+static_assert(regular_invocable<lvalue_qualified, S&>);
+static_assert(!regular_invocable<lvalue_qualified, S const&>);
+static_assert(!regular_invocable<lvalue_qualified, S volatile&>);
+static_assert(!regular_invocable<lvalue_qualified, S const volatile&>);
+static_assert(!regular_invocable<lvalue_qualified, S&&>);
+static_assert(!regular_invocable<lvalue_qualified, S const&&>);
+static_assert(!regular_invocable<lvalue_qualified, S volatile&&>);
+static_assert(!regular_invocable<lvalue_qualified, S const volatile&&>);
+
+#if TEST_STD_VER > 17
+static_assert(check_member_is_invocable<int (S::*)() const&, S>());
+#endif // TEST_STD_VER > 17
+using lvalue_const_qualified = void (S::*)() const&;
+static_assert(regular_invocable<lvalue_const_qualified, S&>);
+static_assert(regular_invocable<lvalue_const_qualified, S const&>);
+static_assert(!regular_invocable<lvalue_const_qualified, S volatile&>);
+static_assert(
+    !regular_invocable<lvalue_const_qualified, S const volatile&>);
+#if TEST_STD_VER > 17
+static_assert(regular_invocable<lvalue_const_qualified, S&&>);
+static_assert(regular_invocable<lvalue_const_qualified, S const&&>);
+#endif // TEST_STD_VER > 17
+static_assert(!regular_invocable<lvalue_const_qualified, S volatile&&>);
+static_assert(
+    !regular_invocable<lvalue_const_qualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)() volatile&, S&>());
+using lvalue_volatile_qualified = void (S::*)() volatile&;
+static_assert(regular_invocable<lvalue_volatile_qualified, S&>);
+static_assert(!regular_invocable<lvalue_volatile_qualified, S const&>);
+static_assert(regular_invocable<lvalue_volatile_qualified, S volatile&>);
+static_assert(
+    !regular_invocable<lvalue_volatile_qualified, S const volatile&>);
+static_assert(!regular_invocable<lvalue_volatile_qualified, S&&>);
+static_assert(!regular_invocable<lvalue_volatile_qualified, S const&&>);
+static_assert(!regular_invocable<lvalue_volatile_qualified, S volatile&&>);
+static_assert(
+    !regular_invocable<lvalue_volatile_qualified, S const volatile&&>);
+
+static_assert(check_member_is_invocable<int (S::*)() const volatile&, S&>());
+using lvalue_cv_qualified = void (S::*)() const volatile&;
+static_assert(regular_invocable<lvalue_cv_qualified, S&>);
+static_assert(regular_invocable<lvalue_cv_qualified, S const&>);
+static_assert(regular_invocable<lvalue_cv_qualified, S volatile&>);
+static_assert(regular_invocable<lvalue_cv_qualified, S const volatile&>);
+static_assert(!regular_invocable<lvalue_cv_qualified, S&&>);
+static_assert(!regular_invocable<lvalue_cv_qualified, S const&&>);
+static_assert(!regular_invocable<lvalue_cv_qualified, S volatile&&>);
+static_assert(!regular_invocable<lvalue_cv_qualified, S const volatile&&>);
+
+using rvalue_unqualified = void (S::*)() &&;
+static_assert(!regular_invocable<rvalue_unqualified, S&>);
+static_assert(!regular_invocable<rvalue_unqualified, S const&>);
+static_assert(!regular_invocable<rvalue_unqualified, S volatile&>);
+static_assert(!regular_invocable<rvalue_unqualified, S const volatile&>);
+static_assert(regular_invocable<rvalue_unqualified, S&&>);
+static_assert(!regular_invocable<rvalue_unqualified, S const&&>);
+static_assert(!regular_invocable<rvalue_unqualified, S volatile&&>);
+static_assert(!regular_invocable<rvalue_unqualified, S const volatile&&>);
+
+using rvalue_const_unqualified = void (S::*)() const&&;
+static_assert(!regular_invocable<rvalue_const_unqualified, S&>);
+static_assert(!regular_invocable<rvalue_const_unqualified, S const&>);
+static_assert(!regular_invocable<rvalue_const_unqualified, S volatile&>);
+static_assert(
+    !regular_invocable<rvalue_const_unqualified, S const volatile&>);
+static_assert(regular_invocable<rvalue_const_unqualified, S&&>);
+static_assert(regular_invocable<rvalue_const_unqualified, S const&&>);
+static_assert(!regular_invocable<rvalue_const_unqualified, S volatile&&>);
+static_assert(
+    !regular_invocable<rvalue_const_unqualified, S const volatile&&>);
+
+using rvalue_volatile_unqualified = void (S::*)() volatile&&;
+static_assert(!regular_invocable<rvalue_volatile_unqualified, S&>);
+static_assert(!regular_invocable<rvalue_volatile_unqualified, S const&>);
+static_assert(
+    !regular_invocable<rvalue_volatile_unqualified, S volatile&>);
+static_assert(
+    !regular_invocable<rvalue_volatile_unqualified, S const volatile&>);
+static_assert(regular_invocable<rvalue_volatile_unqualified, S&&>);
+static_assert(!regular_invocable<rvalue_volatile_unqualified, S const&&>);
+static_assert(
+    regular_invocable<rvalue_volatile_unqualified, S volatile&&>);
+static_assert(
+    !regular_invocable<rvalue_volatile_unqualified, S const volatile&&>);
+
+using rvalue_cv_unqualified = void (S::*)() const volatile&&;
+static_assert(!regular_invocable<rvalue_cv_unqualified, S&>);
+static_assert(!regular_invocable<rvalue_cv_unqualified, S const&>);
+static_assert(!regular_invocable<rvalue_cv_unqualified, S volatile&>);
+static_assert(
+    !regular_invocable<rvalue_cv_unqualified, S const volatile&>);
+static_assert(regular_invocable<rvalue_cv_unqualified, S&&>);
+static_assert(regular_invocable<rvalue_cv_unqualified, S const&&>);
+static_assert(regular_invocable<rvalue_cv_unqualified, S volatile&&>);
+static_assert(
+    regular_invocable<rvalue_cv_unqualified, S const volatile&&>);
+} // namespace pointer_to_member_functions
+
+// Check the concept with closure types (and also check for subsumption)
+#if TEST_STD_VER > 17
+template<class F, class... Args>
+constexpr bool is_regular_invocable(F, Args&&...) {
+  return false;
+}
+
+template<class F, class... Args>
+requires std::invocable<F, Args...>
+constexpr bool is_regular_invocable(F, Args&&...) {
+  return false;
+}
+
+template<class F, class... Args>
+requires regular_invocable<F, Args...> && true
+constexpr bool is_regular_invocable(F, Args&&...) {
+  return true;
+}
+#else
+template<class F, class... Args>
+constexpr bool is_regular_invocable(F, Args&&...) {
+  return regular_invocable<F, Args...>;
+}
+#endif // TEST_STD_VER > 17
+
+#if TEST_STD_VER > 14
+static_assert(is_regular_invocable([] {}));
+static_assert(is_regular_invocable([](int) {}, 0));
+static_assert(is_regular_invocable([](int) {}, 0L));
+static_assert(!is_regular_invocable([](int) {}, nullptr));
+
+int i = 0;
+static_assert(is_regular_invocable([](int&) {}, i));
+#endif // TEST_STD_VER > 14
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.compile.pass.cpp
new file mode 100644
index 0000000000..21886a8fbd
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.compile.pass.cpp
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class F, class... Args>
+// concept relation;
+
+#include <cuda/std/concepts>
+
+using cuda::std::relation;
+
+static_assert(relation<bool(int, int), int, int>);
+static_assert(relation<bool(int, int), double, double>);
+static_assert(relation<bool(int, double), double, double>);
+
+static_assert(!relation<bool(), int, double>);
+static_assert(!relation<bool(int), int, double>);
+static_assert(!relation<bool(double), int, double>);
+static_assert(!relation<bool(double, double*), double, double*>);
+static_assert(!relation<bool(int&, int&), double&, double&>);
+
+struct S1 {};
+static_assert(relation<bool (S1::*)(S1*), S1*, S1*>);
+static_assert(relation<bool (S1::*)(S1&), S1&, S1&>);
+
+struct S2 {};
+
+struct P1 {
+  bool operator()(S1, S1) const;
+};
+static_assert(relation<P1, S1, S1>);
+
+struct P2 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+};
+static_assert(!relation<P2, S1, S2>);
+
+struct P3 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+};
+static_assert(!relation<P3, S1, S2>);
+
+struct P4 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(relation<P4, S1, S2>);
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.compile.pass.cpp
new file mode 100644
index 0000000000..8f0add0e1e
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.relation/relation.subsumption.compile.pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template<class F, class... Args>
+// concept relation;
+
+#include <cuda/std/concepts>
+
+struct S1 {};
+struct S2 {};
+
+struct R {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+
+// clang-format off
+template<class F, class T, class U>
+requires cuda::std::predicate<F, T, T> && cuda::std::predicate<F, T, U> &&
+         cuda::std::predicate<F, U, T> && cuda::std::predicate<F, U, U>
+constexpr bool check_relation_subsumes_predicate() {
+  return false;
+}
+
+template<class F, class T, class U>
+requires cuda::std::relation<F, T, U> && true
+constexpr bool check_relation_subsumes_predicate() {
+  return true;
+}
+// clang-format on
+
+static_assert(
+    check_relation_subsumes_predicate<int (*)(int, double), int, int>());
+static_assert(
+    check_relation_subsumes_predicate<int (*)(int, double), int, double>());
+static_assert(check_relation_subsumes_predicate<R, S1, S1>());
+static_assert(check_relation_subsumes_predicate<R, S1, S2>());
+
+// clang-format off
+template<class F, class T, class U>
+requires cuda::std::relation<F, T, T> && cuda::std::relation<F, U, U>
+constexpr bool check_relation_subsumes_itself() {
+  return false;
+}
+
+template<class F, class T, class U>
+requires cuda::std::relation<F, T, U>
+constexpr bool check_relation_subsumes_itself() {
+  return true;
+}
+// clang-format on
+
+static_assert(check_relation_subsumes_itself<int (*)(int, double), int, int>());
+static_assert(check_relation_subsumes_itself<R, S1, S1>());
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.compile.pass.cpp
new file mode 100644
index 0000000000..afc8c7aed6
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.compile.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class F, class... Args>
+// concept strict_weak_order;
+
+#include <cuda/std/concepts>
+
+using cuda::std::strict_weak_order;
+
+static_assert(strict_weak_order<bool(int, int), int, int>);
+static_assert(strict_weak_order<bool(int, int), double, double>);
+static_assert(strict_weak_order<bool(int, double), double, double>);
+
+static_assert(!strict_weak_order<bool (*)(), int, double>);
+static_assert(!strict_weak_order<bool (*)(int), int, double>);
+static_assert(!strict_weak_order<bool (*)(double), int, double>);
+
+static_assert(!strict_weak_order<bool(double, double*), double, double*>);
+static_assert(!strict_weak_order<bool(int&, int&), double&, double&>);
+
+struct S1 {};
+static_assert(strict_weak_order<bool (S1::*)(S1*), S1*, S1*>);
+static_assert(strict_weak_order<bool (S1::*)(S1&), S1&, S1&>);
+
+struct S2 {};
+
+struct P1 {
+  bool operator()(S1, S1) const;
+};
+static_assert(strict_weak_order<P1, S1, S1>);
+
+struct P2 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+};
+static_assert(!strict_weak_order<P2, S1, S2>);
+
+struct P3 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+};
+static_assert(!strict_weak_order<P3, S1, S2>);
+
+struct P4 {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+static_assert(strict_weak_order<P4, S1, S2>);
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.compile.pass.cpp
new file mode 100644
index 0000000000..876f85864d
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.callable/concept.strictweakorder/strict_weak_order.subsumption.compile.pass.cpp
@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template<class F, class... Args>
+// concept strict_weak_order;
+
+#include <cuda/std/concepts>
+
+struct S1 {};
+struct S2 {};
+
+struct R {
+  bool operator()(S1, S1) const;
+  bool operator()(S1, S2) const;
+  bool operator()(S2, S1) const;
+  bool operator()(S2, S2) const;
+};
+
+// clang-format off
+template<class F, class T, class U>
+requires cuda::std::relation<F, T, U>
+constexpr bool check_strict_weak_order_subsumes_relation() {
+  return false;
+}
+
+template<class F, class T, class U>
+requires cuda::std::strict_weak_order<F, T, U> && true
+constexpr bool check_strict_weak_order_subsumes_relation() {
+  return true;
+}
+// clang-format on
+
+static_assert(check_strict_weak_order_subsumes_relation<int (*)(int, int), int, int>());
+static_assert(check_strict_weak_order_subsumes_relation<int (*)(int, double), int, double>());
+static_assert(check_strict_weak_order_subsumes_relation<R, S1, S1>());
+static_assert(check_strict_weak_order_subsumes_relation<R, S1, S2>());
+
+// clang-format off
+template<class F, class T, class U>
+requires cuda::std::relation<F, T, U> && true
+constexpr bool check_relation_subsumes_strict_weak_order() {
+  return true;
+}
+
+template<class F, class T, class U>
+requires cuda::std::strict_weak_order<F, T, U>
+constexpr bool check_relation_subsumes_strict_weak_order() {
+  return false;
+}
+// clang-format on
+
+static_assert(check_relation_subsumes_strict_weak_order<int (*)(int, int), int, int>());
+static_assert(check_relation_subsumes_strict_weak_order<int (*)(int, double), int, double>());
+static_assert(check_relation_subsumes_strict_weak_order<R, S1, S1>());
+static_assert(check_relation_subsumes_strict_weak_order<R, S1, S2>());
+
+// clang-format off
+template<class F, class T, class U>
+requires cuda::std::strict_weak_order<F, T, T> && cuda::std::strict_weak_order<F, U, U>
+constexpr bool check_strict_weak_order_subsumes_itself() {
+  return false;
+}
+
+template<class F, class T, class U>
+requires cuda::std::strict_weak_order<F, T, U>
+constexpr bool check_strict_weak_order_subsumes_itself() {
+  return true;
+}
+// clang-format on
+
+static_assert(check_strict_weak_order_subsumes_itself<int (*)(int, int), int, int>());
+static_assert(check_strict_weak_order_subsumes_itself<R, S1, S1>());
diff --git a/.upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.compile.pass.cpp
new file mode 100644
index 0000000000..08a143ab06
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.compile.pass.cpp
@@ -0,0 +1,135 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept equality_comparable = // see below
+
+#include <cuda/std/concepts>
+
+#include <cuda/std/array>
+
+#include "compare_types.h"
+
+using cuda::std::equality_comparable;
+
+namespace fundamentals {
+static_assert(equality_comparable<int>);
+static_assert(equality_comparable<double>);
+static_assert(equality_comparable<void*>);
+static_assert(equality_comparable<char*>);
+static_assert(equality_comparable<char const*>);
+static_assert(equality_comparable<char volatile*>);
+static_assert(equality_comparable<char const volatile*>);
+static_assert(equality_comparable<wchar_t&>);
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(equality_comparable<char8_t const&>);
+#endif // TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(equality_comparable<char16_t volatile&>);
+static_assert(equality_comparable<char32_t const volatile&>);
+static_assert(equality_comparable<unsigned char&&>);
+static_assert(equality_comparable<unsigned short const&&>);
+static_assert(equality_comparable<unsigned int volatile&&>);
+static_assert(equality_comparable<unsigned long const volatile&&>);
+static_assert(equality_comparable<int[5]>);
+static_assert(equality_comparable<int (*)(int)>);
+static_assert(equality_comparable<int (&)(int)>);
+static_assert(equality_comparable<int (*)(int) noexcept>);
+static_assert(equality_comparable<int (&)(int) noexcept>);
+static_assert(equality_comparable<cuda::std::nullptr_t>);
+
+struct S {};
+static_assert(equality_comparable<int S::*>);
+static_assert(equality_comparable<int (S::*)()>);
+static_assert(equality_comparable<int (S::*)() noexcept>);
+static_assert(equality_comparable<int (S::*)() &>);
+static_assert(equality_comparable<int (S::*)() & noexcept>);
+static_assert(equality_comparable<int (S::*)() &&>);
+static_assert(equality_comparable<int (S::*)() && noexcept>);
+static_assert(equality_comparable<int (S::*)() const>);
+static_assert(equality_comparable<int (S::*)() const noexcept>);
+static_assert(equality_comparable<int (S::*)() const&>);
+static_assert(equality_comparable<int (S::*)() const & noexcept>);
+static_assert(equality_comparable<int (S::*)() const&&>);
+static_assert(equality_comparable<int (S::*)() const && noexcept>);
+static_assert(equality_comparable<int (S::*)() volatile>);
+static_assert(equality_comparable<int (S::*)() volatile noexcept>);
+static_assert(equality_comparable<int (S::*)() volatile&>);
+static_assert(equality_comparable<int (S::*)() volatile & noexcept>);
+static_assert(equality_comparable<int (S::*)() volatile&&>);
+static_assert(equality_comparable<int (S::*)() volatile && noexcept>);
+static_assert(equality_comparable<int (S::*)() const volatile>);
+static_assert(equality_comparable<int (S::*)() const volatile noexcept>);
+static_assert(equality_comparable<int (S::*)() const volatile&>);
+static_assert(equality_comparable<int (S::*)() const volatile & noexcept>);
+static_assert(equality_comparable<int (S::*)() const volatile&&>);
+static_assert(
+    equality_comparable<int (S::*)() const volatile && noexcept>);
+
+static_assert(!equality_comparable<void>);
+} // namespace fundamentals
+
+namespace standard_types {
+static_assert(equality_comparable<cuda::std::array<int, 10>>);
+} // namespace standard_types
+
+namespace types_fit_for_purpose {
+#if TEST_STD_VER > 17
+static_assert(equality_comparable<cxx20_member_eq>);
+static_assert(equality_comparable<cxx20_friend_eq>);
+static_assert(equality_comparable<member_three_way_comparable>);
+static_assert(equality_comparable<friend_three_way_comparable>);
+static_assert(equality_comparable<explicit_operators>);
+static_assert(equality_comparable<different_return_types>);
+static_assert(equality_comparable<one_member_one_friend>);
+static_assert(equality_comparable<equality_comparable_with_ec1>);
+#endif // TEST_STD_VER > 17
+
+static_assert(!equality_comparable<no_eq>);
+static_assert(!equality_comparable<no_neq>);
+static_assert(equality_comparable<no_lt>);
+static_assert(equality_comparable<no_gt>);
+static_assert(equality_comparable<no_le>);
+static_assert(equality_comparable<no_ge>);
+
+static_assert(!equality_comparable<wrong_return_type_eq>);
+static_assert(!equality_comparable<wrong_return_type_ne>);
+static_assert(equality_comparable<wrong_return_type_lt>);
+static_assert(equality_comparable<wrong_return_type_gt>);
+static_assert(equality_comparable<wrong_return_type_le>);
+static_assert(equality_comparable<wrong_return_type_ge>);
+static_assert(!equality_comparable<wrong_return_type>);
+
+#if TEST_STD_VER > 17
+static_assert(
+    !equality_comparable<cxx20_member_eq_operator_with_deleted_ne>);
+static_assert(
+    !equality_comparable<cxx20_friend_eq_operator_with_deleted_ne>);
+static_assert(
+    !equality_comparable<member_three_way_comparable_with_deleted_eq>);
+static_assert(
+    !equality_comparable<member_three_way_comparable_with_deleted_ne>);
+static_assert(
+    !equality_comparable<friend_three_way_comparable_with_deleted_eq>);
+static_assert(
+    !equality_comparable<friend_three_way_comparable_with_deleted_ne>);
+#endif // TEST_STD_VER > 17
+
+static_assert(!equality_comparable<eq_returns_explicit_bool>);
+static_assert(!equality_comparable<ne_returns_explicit_bool>);
+static_assert(equality_comparable<lt_returns_explicit_bool>);
+static_assert(equality_comparable<gt_returns_explicit_bool>);
+static_assert(equality_comparable<le_returns_explicit_bool>);
+static_assert(equality_comparable<ge_returns_explicit_bool>);
+static_assert(equality_comparable<returns_true_type>);
+static_assert(equality_comparable<returns_int_ptr>);
+} // namespace types_fit_for_purpose
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
new file mode 100644
index 0000000000..1cc71bed1b
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp
@@ -0,0 +1,1085 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T, class U>
+// concept equality_comparable_with = // see below
+
+#include <cuda/std/concepts>
+
+#include <cuda/std/array>
+
+#include "test_macros.h"
+#include "compare_types.h"
+
+using cuda::std::equality_comparable_with;
+using cuda::std::nullptr_t;
+
+template <class T, class U>
+constexpr bool check_equality_comparable_with() {
+  constexpr bool result = equality_comparable_with<T, U>;
+  static_assert(equality_comparable_with<U, T> == result);
+  static_assert(equality_comparable_with<T, U const> == result);
+  static_assert(equality_comparable_with<T const, U const> == result);
+  static_assert(equality_comparable_with<T, U const&> == result);
+  static_assert(equality_comparable_with<T const, U const&> == result);
+  static_assert(equality_comparable_with<T&, U const> == result);
+  static_assert(equality_comparable_with<T const&, U const> == result);
+  static_assert(equality_comparable_with<T&, U const&> == result);
+  static_assert(equality_comparable_with<T const&, U const&> == result);
+  static_assert(equality_comparable_with<T, U const&&> == result);
+  static_assert(equality_comparable_with<T const, U const&&> == result);
+  static_assert(equality_comparable_with<T&, U const&&> == result);
+  static_assert(equality_comparable_with<T const&, U const&&> == result);
+  static_assert(equality_comparable_with<T&&, U const> == result);
+  static_assert(equality_comparable_with<T const&&, U const> == result);
+  static_assert(equality_comparable_with<T&&, U const&> == result);
+  static_assert(equality_comparable_with<T const&&, U const&> == result);
+  static_assert(equality_comparable_with<T&&, U const&&> == result);
+  static_assert(equality_comparable_with<T const&&, U const&&> == result);
+  return result;
+}
+
+namespace fundamentals {
+static_assert(check_equality_comparable_with<int, int>());
+static_assert(check_equality_comparable_with<int, bool>());
+static_assert(check_equality_comparable_with<int, char>());
+static_assert(check_equality_comparable_with<int, wchar_t>());
+static_assert(check_equality_comparable_with<int, double>());
+static_assert(!check_equality_comparable_with<int, int*>());
+static_assert(!check_equality_comparable_with<int, int[5]>());
+static_assert(!check_equality_comparable_with<int, int (*)()>());
+static_assert(!check_equality_comparable_with<int, int (&)()>());
+
+struct S {};
+static_assert(!check_equality_comparable_with<int, int S::*>());
+static_assert(!check_equality_comparable_with<int, int (S::*)()>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() volatile>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int, int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() const&>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() const volatile &
+                                                       noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int, int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int*, int*>());
+static_assert(check_equality_comparable_with<int*, int[5]>());
+static_assert(!check_equality_comparable_with<int*, int (*)()>());
+static_assert(!check_equality_comparable_with<int*, int (&)()>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)()>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int*, int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() const&>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int*, int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int*,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int*,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int*,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int*,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int[5], int[5]>());
+static_assert(!check_equality_comparable_with<int[5], int (*)()>());
+static_assert(!check_equality_comparable_with<int[5], int (&)()>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)()>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() volatile>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int[5], int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() &>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() const&>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() volatile &
+                                                          noexcept>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int[5], int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int[5],
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int[5],
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int[5],
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int[5],
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (*)(), int (*)()>());
+static_assert(check_equality_comparable_with<int (*)(), int (&)()>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)()>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (*)(), int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (*)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() &>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (*)(),
+                                              int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() volatile &
+                                                             noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (*)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (*)(),
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (*)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (*)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (*)(),
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (*)(),
+              int (S::*)() const volatile&& noexcept > ());
+
+#if TEST_STD_VER > 17
+static_assert(check_equality_comparable_with<int (&)(), int (&)()>());
+#endif // TEST_STD_VER > 17
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)()>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (&)(), int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (&)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() &>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (&)(),
+                                              int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() volatile &
+                                                             noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (&)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (&)(),
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (&)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (&)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (&)(),
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (&)(),
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)(), int (S::*)()>());
+static_assert(
+    check_equality_comparable_with<int (S::*)(), int (S::*)() noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() const>());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)(), int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)(), int (S::*)() &>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)(), int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)(), int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)(),
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)(),
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() noexcept,
+                                             int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() noexcept, int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() noexcept, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() noexcept, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() noexcept, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() noexcept, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() noexcept, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() const, int (S::*)() const>());
+static_assert(check_equality_comparable_with<int (S::*)() const,
+                                             int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const, int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const, int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const noexcept,
+                                             int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const noexcept, int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const volatile>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const noexcept,
+                                    int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const noexcept, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() volatile,
+                                             int (S::*)() volatile>());
+static_assert(check_equality_comparable_with<int (S::*)() volatile,
+                                             int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() volatile, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() volatile, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() volatile, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                             int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const volatile>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                    int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                    int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const volatile,
+                                             int (S::*)() const volatile>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile,
+                                   int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                   int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() const&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() &, int (S::*)() &>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() &, int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() &,
+                                              int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() &, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() &,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() &, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() &,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() & noexcept,
+                                             int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() & noexcept, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() & noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() const&, int (S::*)() const&>());
+static_assert(check_equality_comparable_with<int (S::*)() const&,
+                                             int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const&, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const&, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const&, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const & noexcept,
+                                             int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const & noexcept,
+                                    int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const & noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() volatile&,
+                                             int (S::*)() volatile&>());
+static_assert(check_equality_comparable_with<
+              int (S::*)() volatile&, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile&,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile&, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                   int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const volatile&,
+                                             int (S::*)() const volatile&>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile&,
+                                   int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile & noexcept,
+                                   int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile & noexcept, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile & noexcept, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile & noexcept,
+                                    int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile & noexcept,
+                                    int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() &&, int (S::*)() &&>());
+static_assert(check_equality_comparable_with<int (S::*)() &&,
+                                             int (S::*)() && noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &&, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() &&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() &&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() && noexcept,
+                                             int (S::*)() && noexcept>());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() const&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() volatile&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const&&,
+                                             int (S::*)() const&&>());
+static_assert(check_equality_comparable_with<int (S::*)() const&&,
+                                             int (S::*)() const && noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const&&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const&&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const && noexcept,
+                                             int (S::*)() const && noexcept>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
+              int (S::*)() volatile&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() volatile&&,
+                                             int (S::*)() volatile&&>());
+static_assert(check_equality_comparable_with<
+              int (S::*)() volatile&&, int (S::*)() volatile && noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() volatile && noexcept,
+                                   int (S::*)() volatile && noexcept>());
+static_assert(!check_equality_comparable_with <
+                  int (S::*)() volatile&& noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_equality_comparable_with <
+                  int (S::*)() volatile&& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const volatile&&,
+                                             int (S::*)() const volatile&&>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile&&,
+                                   int (S::*)() const volatile && noexcept>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile && noexcept,
+                                   int (S::*)() const volatile && noexcept>());
+
+static_assert(!check_equality_comparable_with<nullptr_t, int>());
+static_assert(check_equality_comparable_with<nullptr_t, int*>());
+static_assert(check_equality_comparable_with<nullptr_t, int[5]>());
+static_assert(check_equality_comparable_with<nullptr_t, int (*)()>());
+static_assert(check_equality_comparable_with<nullptr_t, int (&)()>());
+static_assert(check_equality_comparable_with<nullptr_t, int (S::*)()>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() noexcept>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() const>());
+static_assert(check_equality_comparable_with<nullptr_t,
+                                             int (S::*)() const noexcept>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() volatile>());
+static_assert(check_equality_comparable_with<nullptr_t,
+                                             int (S::*)() volatile noexcept>());
+static_assert(check_equality_comparable_with<nullptr_t,
+                                             int (S::*)() const volatile>());
+static_assert(check_equality_comparable_with<
+              nullptr_t, int (S::*)() const volatile noexcept>());
+static_assert(check_equality_comparable_with<nullptr_t, int (S::*)() &>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() & noexcept>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() const&>());
+static_assert(check_equality_comparable_with<nullptr_t,
+                                             int (S::*)() const & noexcept>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() volatile&>());
+static_assert(check_equality_comparable_with<
+              nullptr_t, int (S::*)() volatile & noexcept>());
+static_assert(check_equality_comparable_with<nullptr_t,
+                                             int (S::*)() const volatile&>());
+static_assert(check_equality_comparable_with<
+              nullptr_t, int (S::*)() const volatile & noexcept>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() &&>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() && noexcept>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() const&&>());
+static_assert(check_equality_comparable_with<nullptr_t,
+                                             int (S::*)() const && noexcept>());
+static_assert(
+    check_equality_comparable_with<nullptr_t, int (S::*)() volatile&&>());
+static_assert(check_equality_comparable_with<
+              nullptr_t, int (S::*)() volatile && noexcept>());
+static_assert(check_equality_comparable_with<nullptr_t,
+                                             int (S::*)() const volatile&&>());
+static_assert(check_equality_comparable_with<
+              nullptr_t, int (S::*)() const volatile && noexcept>());
+
+static_assert(!equality_comparable_with<void, int>);
+static_assert(!equality_comparable_with<void, int*>);
+static_assert(!equality_comparable_with<void, nullptr_t>);
+static_assert(!equality_comparable_with<void, int[5]>);
+static_assert(!equality_comparable_with<void, int (*)()>);
+static_assert(!equality_comparable_with<void, int (&)()>);
+static_assert(!equality_comparable_with<void, int S::*>);
+static_assert(!equality_comparable_with<void, int (S::*)()>);
+static_assert(!equality_comparable_with<void, int (S::*)() noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() const>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() volatile>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() volatile noexcept>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const volatile>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const volatile noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() &>);
+static_assert(!equality_comparable_with<void, int (S::*)() & noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() const&>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const & noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() volatile&>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() volatile & noexcept>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const volatile&>);
+static_assert(!equality_comparable_with<void, int (S::*)() const volatile &
+                                                       noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() &&>);
+static_assert(!equality_comparable_with < void,
+              int (S::*)() && noexcept >);
+static_assert(!equality_comparable_with<void, int (S::*)() const&&>);
+static_assert(!equality_comparable_with < void,
+              int (S::*)() const&& noexcept >);
+static_assert(!equality_comparable_with<void, int (S::*)() volatile&&>);
+static_assert(!equality_comparable_with < void,
+              int (S::*)() volatile&& noexcept >);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const volatile&&>);
+static_assert(!equality_comparable_with < void,
+              int (S::*)() const volatile&& noexcept >);
+} // namespace fundamentals
+
+namespace standard_types {
+static_assert(check_equality_comparable_with<cuda::std::array<int, 10>,
+                                             cuda::std::array<int, 10> >());
+static_assert(!check_equality_comparable_with<cuda::std::array<int, 10>,
+                                              cuda::std::array<double, 10> >());
+} // namespace standard_types
+
+namespace types_fit_for_purpose {
+#if TEST_STD_VER > 17
+static_assert(
+    check_equality_comparable_with<cxx20_member_eq, cxx20_member_eq>());
+static_assert(
+    check_equality_comparable_with<cxx20_friend_eq, cxx20_friend_eq>());
+static_assert(
+    !check_equality_comparable_with<cxx20_member_eq, cxx20_friend_eq>());
+
+static_assert(check_equality_comparable_with<member_three_way_comparable,
+                                             member_three_way_comparable>());
+static_assert(check_equality_comparable_with<friend_three_way_comparable,
+                                             friend_three_way_comparable>());
+static_assert(!check_equality_comparable_with<member_three_way_comparable,
+                                              friend_three_way_comparable>());
+#endif // TEST_STD_VER > 17
+
+static_assert(
+    check_equality_comparable_with<explicit_operators, explicit_operators>());
+static_assert(check_equality_comparable_with<equality_comparable_with_ec1,
+                                             equality_comparable_with_ec1>());
+static_assert(check_equality_comparable_with<different_return_types,
+                                             different_return_types>());
+static_assert(check_equality_comparable_with<explicit_operators,
+                                             equality_comparable_with_ec1>());
+static_assert(check_equality_comparable_with<explicit_operators,
+                                             different_return_types>());
+
+#if TEST_STD_VER > 17
+static_assert(check_equality_comparable_with<one_way_eq, one_way_eq>());
+static_assert(
+    cuda::std::common_reference_with<one_way_eq const&, explicit_operators const&>);
+static_assert(
+    !check_equality_comparable_with<one_way_eq, explicit_operators>());
+
+static_assert(check_equality_comparable_with<one_way_ne, one_way_ne>());
+static_assert(
+    cuda::std::common_reference_with<one_way_ne const&, explicit_operators const&>);
+static_assert(
+    !check_equality_comparable_with<one_way_ne, explicit_operators>());
+#endif // TEST_STD_VER > 17
+} // namespace types_fit_for_purpose
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered.pass.cpp b/.upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered.pass.cpp
new file mode 100644
index 0000000000..d31d43a49f
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered.pass.cpp
@@ -0,0 +1,158 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept totally_ordered;
+
+#include <cuda/std/concepts>
+
+#include <cuda/std/array>
+
+#include "compare_types.h"
+#include "test_macros.h"
+
+using cuda::std::totally_ordered;
+
+// `models_totally_ordered` checks that `totally_ordered` subsumes
+// `std::equality_comparable`. This overload should *never* be called.
+#if TEST_STD_VER > 17
+template <std::equality_comparable T>
+constexpr bool models_totally_ordered() noexcept {
+  return false;
+}
+#endif // TEST_STD_VER > 17
+
+_LIBCUDACXX_TEMPLATE(class T)
+  (requires cuda::std::totally_ordered<T>)
+constexpr bool models_totally_ordered() noexcept {
+  return true;
+}
+
+namespace fundamentals {
+static_assert(models_totally_ordered<int>());
+static_assert(models_totally_ordered<double>());
+static_assert(models_totally_ordered<void*>());
+static_assert(models_totally_ordered<char*>());
+static_assert(models_totally_ordered<char const*>());
+static_assert(models_totally_ordered<char volatile*>());
+static_assert(models_totally_ordered<char const volatile*>());
+static_assert(models_totally_ordered<wchar_t&>());
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(models_totally_ordered<char8_t const&>());
+#endif // TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(models_totally_ordered<char16_t volatile&>());
+static_assert(models_totally_ordered<char32_t const volatile&>());
+static_assert(models_totally_ordered<unsigned char&&>());
+static_assert(models_totally_ordered<unsigned short const&&>());
+static_assert(models_totally_ordered<unsigned int volatile&&>());
+static_assert(models_totally_ordered<unsigned long const volatile&&>());
+static_assert(models_totally_ordered<int[5]>());
+static_assert(models_totally_ordered<int (*)(int)>());
+static_assert(models_totally_ordered<int (&)(int)>());
+static_assert(models_totally_ordered<int (*)(int) noexcept>());
+static_assert(models_totally_ordered<int (&)(int) noexcept>());
+
+#ifndef TEST_COMPILER_GCC
+static_assert(!totally_ordered<cuda::std::nullptr_t>);
+#endif
+
+struct S {};
+static_assert(!totally_ordered<S>);
+static_assert(!totally_ordered<int S::*>);
+static_assert(!totally_ordered<int (S::*)()>);
+static_assert(!totally_ordered<int (S::*)() noexcept>);
+static_assert(!totally_ordered<int (S::*)() &>);
+static_assert(!totally_ordered<int (S::*)() & noexcept>);
+static_assert(!totally_ordered<int (S::*)() &&>);
+static_assert(!totally_ordered < int (S::*)() && noexcept >);
+static_assert(!totally_ordered<int (S::*)() const>);
+static_assert(!totally_ordered<int (S::*)() const noexcept>);
+static_assert(!totally_ordered<int (S::*)() const&>);
+static_assert(!totally_ordered<int (S::*)() const & noexcept>);
+static_assert(!totally_ordered<int (S::*)() const&&>);
+static_assert(!totally_ordered < int (S::*)() const&& noexcept >);
+static_assert(!totally_ordered<int (S::*)() volatile>);
+static_assert(!totally_ordered<int (S::*)() volatile noexcept>);
+static_assert(!totally_ordered<int (S::*)() volatile&>);
+static_assert(!totally_ordered<int (S::*)() volatile & noexcept>);
+static_assert(!totally_ordered<int (S::*)() volatile&&>);
+static_assert(!totally_ordered < int (S::*)() volatile&& noexcept >);
+static_assert(!totally_ordered<int (S::*)() const volatile>);
+static_assert(!totally_ordered<int (S::*)() const volatile noexcept>);
+static_assert(!totally_ordered<int (S::*)() const volatile&>);
+static_assert(!totally_ordered<int (S::*)() const volatile & noexcept>);
+static_assert(!totally_ordered<int (S::*)() const volatile&&>);
+static_assert(!totally_ordered < int (S::*)() const volatile&& noexcept >);
+
+static_assert(!totally_ordered<void>);
+} // namespace fundamentals
+
+namespace standard_types {
+static_assert(models_totally_ordered<cuda::std::array<int, 10> >());
+} // namespace standard_types
+
+namespace types_fit_for_purpose {
+#if TEST_STD_VER > 17
+static_assert(models_totally_ordered<member_three_way_comparable>());
+static_assert(models_totally_ordered<friend_three_way_comparable>());
+static_assert(models_totally_ordered<explicit_operators>());
+static_assert(models_totally_ordered<different_return_types>());
+static_assert(!totally_ordered<cxx20_member_eq>);
+static_assert(!totally_ordered<cxx20_friend_eq>);
+static_assert(!totally_ordered<one_member_one_friend>);
+static_assert(!totally_ordered<equality_comparable_with_ec1>);
+#endif // TEST_STD_VER > 17
+
+static_assert(!totally_ordered<no_eq>);
+static_assert(!totally_ordered<no_neq>);
+static_assert(!totally_ordered<no_lt>);
+static_assert(!totally_ordered<no_gt>);
+static_assert(!totally_ordered<no_le>);
+static_assert(!totally_ordered<no_ge>);
+
+static_assert(!totally_ordered<wrong_return_type_eq>);
+static_assert(!totally_ordered<wrong_return_type_ne>);
+static_assert(!totally_ordered<wrong_return_type_lt>);
+static_assert(!totally_ordered<wrong_return_type_gt>);
+static_assert(!totally_ordered<wrong_return_type_le>);
+static_assert(!totally_ordered<wrong_return_type_ge>);
+static_assert(!totally_ordered<wrong_return_type>);
+
+#if TEST_STD_VER > 17
+static_assert(!totally_ordered<cxx20_member_eq_operator_with_deleted_ne>);
+static_assert(!totally_ordered<cxx20_friend_eq_operator_with_deleted_ne>);
+static_assert(
+    !totally_ordered<member_three_way_comparable_with_deleted_eq>);
+static_assert(
+    !totally_ordered<member_three_way_comparable_with_deleted_ne>);
+static_assert(
+    !totally_ordered<friend_three_way_comparable_with_deleted_eq>);
+static_assert(
+    !totally_ordered<friend_three_way_comparable_with_deleted_ne>);
+#endif // TEST_STD_VER > 17
+
+static_assert(!totally_ordered<eq_returns_explicit_bool>);
+static_assert(!totally_ordered<ne_returns_explicit_bool>);
+static_assert(!totally_ordered<lt_returns_explicit_bool>);
+static_assert(!totally_ordered<gt_returns_explicit_bool>);
+static_assert(!totally_ordered<le_returns_explicit_bool>);
+static_assert(!totally_ordered<ge_returns_explicit_bool>);
+static_assert(totally_ordered<returns_true_type>);
+static_assert(totally_ordered<returns_int_ptr>);
+
+#if TEST_STD_VER > 17
+static_assert(totally_ordered<partial_ordering_totally_ordered_with>);
+static_assert(totally_ordered<weak_ordering_totally_ordered_with>);
+static_assert(totally_ordered<strong_ordering_totally_ordered_with>);
+#endif // TEST_STD_VER > 17
+} // namespace types_fit_for_purpose
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered_with.pass.cpp b/.upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered_with.pass.cpp
new file mode 100644
index 0000000000..b2cb94edb6
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.compare/concepts.totallyordered/totally_ordered_with.pass.cpp
@@ -0,0 +1,1109 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept totally_ordered_with;
+
+#include <cuda/std/concepts>
+
+#include <cuda/std/array>
+
+#include "compare_types.h"
+#include "test_macros.h"
+
+using cuda::std::totally_ordered_with;
+using cuda::std::equality_comparable_with;
+using cuda::std::nullptr_t;
+
+template <class T, class U>
+constexpr bool check_totally_ordered_with() noexcept {
+  constexpr bool result = totally_ordered_with<T, U>;
+  static_assert(totally_ordered_with<U, T> == result);
+  static_assert(totally_ordered_with<T, U const> == result);
+  static_assert(totally_ordered_with<T const, U const> == result);
+  static_assert(totally_ordered_with<T, U const&> == result);
+  static_assert(totally_ordered_with<T const, U const&> == result);
+  static_assert(totally_ordered_with<T&, U const> == result);
+  static_assert(totally_ordered_with<T const&, U const> == result);
+  static_assert(totally_ordered_with<T&, U const&> == result);
+  static_assert(totally_ordered_with<T const&, U const&> == result);
+  static_assert(totally_ordered_with<T, U const&&> == result);
+  static_assert(totally_ordered_with<T const, U const&&> == result);
+  static_assert(totally_ordered_with<T&, U const&&> == result);
+  static_assert(totally_ordered_with<T const&, U const&&> == result);
+  static_assert(totally_ordered_with<T&&, U const> == result);
+  static_assert(totally_ordered_with<T const&&, U const> == result);
+  static_assert(totally_ordered_with<T&&, U const&> == result);
+  static_assert(totally_ordered_with<T const&&, U const&> == result);
+  static_assert(totally_ordered_with<T&&, U const&&> == result);
+  static_assert(totally_ordered_with<T const&&, U const&&> == result);
+  return result;
+}
+
+namespace fundamentals {
+static_assert(check_totally_ordered_with<int, int>());
+static_assert(check_totally_ordered_with<int, bool>());
+static_assert(check_totally_ordered_with<int, char>());
+static_assert(check_totally_ordered_with<int, wchar_t>());
+static_assert(check_totally_ordered_with<int, double>());
+static_assert(!check_totally_ordered_with<int, int*>());
+static_assert(!check_totally_ordered_with<int, int[5]>());
+static_assert(!check_totally_ordered_with<int, int (*)()>());
+static_assert(!check_totally_ordered_with<int, int (&)()>());
+
+struct S {};
+static_assert(!check_totally_ordered_with<int, int S::*>());
+static_assert(!check_totally_ordered_with<int, int (S::*)()>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() noexcept>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() const>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() const noexcept>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() volatile>());
+static_assert(
+    !check_totally_ordered_with<int, int (S::*)() volatile noexcept>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() const volatile>());
+static_assert(
+    !check_totally_ordered_with<int, int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() const&>());
+static_assert(
+    !check_totally_ordered_with<int, int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() volatile&>());
+static_assert(
+    !check_totally_ordered_with<int, int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int, int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int, int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int, int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int, int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_totally_ordered_with<int*, int*>());
+static_assert(check_totally_ordered_with<int*, int[5]>());
+static_assert(!check_totally_ordered_with<int*, int (*)()>());
+static_assert(!check_totally_ordered_with<int*, int (&)()>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)()>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() noexcept>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() const>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() const noexcept>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() volatile>());
+static_assert(
+    !check_totally_ordered_with<int*, int (S::*)() volatile noexcept>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() const volatile>());
+static_assert(
+    !check_totally_ordered_with<int*, int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() const&>());
+static_assert(
+    !check_totally_ordered_with<int*, int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() volatile&>());
+static_assert(
+    !check_totally_ordered_with<int*, int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int*, int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() const volatile &
+                                                    noexcept>());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int*,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int*,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int*, int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int*,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int*, int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int*,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_totally_ordered_with<int[5], int[5]>());
+static_assert(!check_totally_ordered_with<int[5], int (*)()>());
+static_assert(!check_totally_ordered_with<int[5], int (&)()>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)()>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() noexcept>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() const>());
+static_assert(
+    !check_totally_ordered_with<int[5], int (S::*)() const noexcept>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() volatile>());
+static_assert(
+    !check_totally_ordered_with<int[5], int (S::*)() volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int[5], int (S::*)() const volatile>());
+static_assert(!check_totally_ordered_with<
+              int[5], int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() const&>());
+static_assert(
+    !check_totally_ordered_with<int[5], int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() volatile&>());
+static_assert(
+    !check_totally_ordered_with<int[5], int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int[5], int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() const volatile &
+                                                      noexcept>());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int[5],
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int[5],
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int[5], int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int[5],
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int[5], int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int[5],
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_totally_ordered_with<int (*)(), int (*)()>());
+static_assert(check_totally_ordered_with<int (*)(), int (&)()>());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)()>());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)() noexcept>());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)() const>());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() const noexcept>());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)() volatile>());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() const volatile>());
+static_assert(!check_totally_ordered_with<
+              int (*)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)() &>());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)() const&>());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)() volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              int (*)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (*)(),
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (*)(), int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (*)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (*)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (*)(), int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (*)(),
+              int (S::*)() const volatile&& noexcept > ());
+#if TEST_STD_VER > 17
+static_assert(check_totally_ordered_with<int (&)(), int (&)()>());
+#endif // TEST_STD_VER > 17
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)()>());
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)() noexcept>());
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)() const>());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() const noexcept>());
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)() volatile>());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() const volatile>());
+static_assert(!check_totally_ordered_with<
+              int (&)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)() &>());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)() const&>());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)() volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              int (&)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (&)(),
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (&)(), int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (&)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (&)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (&)(), int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (&)(),
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)(), int (S::*)()>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)(), int (S::*)() const>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() const noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() volatile>());
+static_assert(!check_totally_ordered_with<int (S::*)(),
+                                          int (S::*)() volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() const volatile>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)(), int (S::*)() &>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)(), int (S::*)() const&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() const & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)(),
+                                          int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)(), int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)(),
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)(), int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)(),
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() noexcept, int (S::*)() const>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() const noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() volatile>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() const volatile>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() noexcept, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() noexcept, int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() noexcept, int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() noexcept, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() noexcept, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() noexcept, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() noexcept,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() const>());
+static_assert(!check_totally_ordered_with<int (S::*)() const,
+                                          int (S::*)() const noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() volatile>());
+static_assert(!check_totally_ordered_with<int (S::*)() const,
+                                          int (S::*)() volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const,
+                                          int (S::*)() const volatile>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() const, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() &>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const,
+                                          int (S::*)() const & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const,
+                                          int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() const, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const, int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() const noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() volatile>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() const volatile>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const noexcept,
+                                int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const noexcept, int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const noexcept,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const noexcept,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() volatile>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() const volatile>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() volatile, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile, int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile, int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() volatile, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() const volatile>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile noexcept,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() const volatile>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile,
+                                int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile, int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() &>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile noexcept,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() &, int (S::*)() &>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() &, int (S::*)() & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() &, int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() &,
+                                          int (S::*)() const & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() &, int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() &,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() &,
+                                          int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() &, int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() &, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() &,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() &, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() &,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() &, int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() &,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() &,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() &,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() & noexcept,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() & noexcept, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() & noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() & noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() & noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() & noexcept,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() & noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const&, int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const&,
+                                          int (S::*)() const & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const&, int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const&,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const&,
+                                          int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() const&, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const&, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const&,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const&, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const&,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const&,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() const & noexcept,
+                                          int (S::*)() const & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const & noexcept,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() const & noexcept,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const & noexcept,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const & noexcept,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const & noexcept,
+                                          int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const & noexcept,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const & noexcept,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const & noexcept,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() volatile&,
+                                          int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile&,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile&,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile&,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile&, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile&,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile&,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile&,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() volatile & noexcept,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile & noexcept,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() volatile & noexcept,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile & noexcept,
+                                          int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile & noexcept,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile & noexcept,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile & noexcept,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile&,
+                                          int (S::*)() const volatile&>());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile&,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile&,
+                                          int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile&,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile&,
+                                          int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile&,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile&,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile & noexcept,
+                                int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() const volatile & noexcept, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with<
+              int (S::*)() const volatile & noexcept, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile & noexcept,
+                                int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const volatile & noexcept,
+                                int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() &&, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < int (S::*)() &&,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() &&, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() &&,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<int (S::*)() &&, int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() &&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() &&,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() &&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with < int (S::*)() && noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_totally_ordered_with < int (S::*)() && noexcept,
+              int (S::*)() const&& > ());
+static_assert(!check_totally_ordered_with < int (S::*)() && noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with < int (S::*)() && noexcept,
+              int (S::*)() volatile&& > ());
+static_assert(!check_totally_ordered_with < int (S::*)() && noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with < int (S::*)() && noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_totally_ordered_with < int (S::*)() && noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    !check_totally_ordered_with<int (S::*)() const&&, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const&&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const&&,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const&&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() const&&,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const&&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with < int (S::*)() const&& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_totally_ordered_with < int (S::*)() const&& noexcept,
+              int (S::*)() volatile&& > ());
+static_assert(!check_totally_ordered_with < int (S::*)() const&& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with < int (S::*)() const&& noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_totally_ordered_with < int (S::*)() const&& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() volatile&&,
+                                          int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<int (S::*)() volatile&&,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&& noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_totally_ordered_with < int (S::*)() volatile&& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!check_totally_ordered_with<int (S::*)() const volatile&&,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < int (S::*)() const volatile&&,
+              int (S::*)() const volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with < int (S::*)()
+                                                const volatile&& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+#if !defined(TEST_COMPILER_GCC)
+static_assert(!check_totally_ordered_with<nullptr_t, int>());
+
+static_assert(!check_totally_ordered_with<nullptr_t, int*>());
+static_assert(!check_totally_ordered_with<nullptr_t, int[]>());
+static_assert(!check_totally_ordered_with<nullptr_t, int[5]>());
+static_assert(!check_totally_ordered_with<nullptr_t, int (*)()>());
+static_assert(!check_totally_ordered_with<nullptr_t, int (&)()>());
+#endif
+
+static_assert(!check_totally_ordered_with<nullptr_t, int (S::*)()>());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() noexcept>());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() const>());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() const noexcept>());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() volatile>());
+static_assert(!check_totally_ordered_with<nullptr_t,
+                                          int (S::*)() volatile noexcept>());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() const volatile>());
+static_assert(!check_totally_ordered_with<
+              nullptr_t, int (S::*)() const volatile noexcept>());
+static_assert(!check_totally_ordered_with<nullptr_t, int (S::*)() &>());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() & noexcept>());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() const&>());
+static_assert(!check_totally_ordered_with<nullptr_t,
+                                          int (S::*)() const & noexcept>());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() volatile&>());
+static_assert(!check_totally_ordered_with<nullptr_t,
+                                          int (S::*)() volatile & noexcept>());
+static_assert(!check_totally_ordered_with<nullptr_t,
+                                          int (S::*)() const volatile&>());
+static_assert(!check_totally_ordered_with<
+              nullptr_t, int (S::*)() const volatile & noexcept>());
+static_assert(!check_totally_ordered_with<nullptr_t, int (S::*)() &&>());
+static_assert(!check_totally_ordered_with < nullptr_t,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() const&&>());
+static_assert(!check_totally_ordered_with < nullptr_t,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_totally_ordered_with<nullptr_t, int (S::*)() volatile&&>());
+static_assert(!check_totally_ordered_with < nullptr_t,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_totally_ordered_with<nullptr_t,
+                                          int (S::*)() const volatile&&>());
+static_assert(!check_totally_ordered_with < nullptr_t,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(!equality_comparable_with<void, int>);
+static_assert(!equality_comparable_with<void, int*>);
+static_assert(!equality_comparable_with<void, nullptr_t>);
+static_assert(!equality_comparable_with<void, int[5]>);
+static_assert(!equality_comparable_with<void, int (*)()>);
+static_assert(!equality_comparable_with<void, int (&)()>);
+static_assert(!equality_comparable_with<void, int S::*>);
+static_assert(!equality_comparable_with<void, int (S::*)()>);
+static_assert(!equality_comparable_with<void, int (S::*)() noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() const>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() volatile>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() volatile noexcept>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const volatile>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const volatile noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() &>);
+static_assert(!equality_comparable_with<void, int (S::*)() & noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() const&>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const & noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() volatile&>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() volatile & noexcept>);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const volatile&>);
+static_assert(!equality_comparable_with<void, int (S::*)() const volatile &
+                                                       noexcept>);
+static_assert(!equality_comparable_with<void, int (S::*)() &&>);
+static_assert(!equality_comparable_with < void,
+              int (S::*)() && noexcept >);
+static_assert(!equality_comparable_with<void, int (S::*)() const&&>);
+static_assert(!equality_comparable_with < void,
+              int (S::*)() const&& noexcept >);
+static_assert(!equality_comparable_with<void, int (S::*)() volatile&&>);
+static_assert(!equality_comparable_with < void,
+              int (S::*)() volatile&& noexcept >);
+static_assert(
+    !equality_comparable_with<void, int (S::*)() const volatile&&>);
+static_assert(!equality_comparable_with < void,
+              int (S::*)() const volatile&& noexcept >);
+} // namespace fundamentals
+
+namespace standard_types {
+static_assert(
+    check_totally_ordered_with<cuda::std::array<int, 10>, cuda::std::array<int, 10> >());
+static_assert(!check_totally_ordered_with<cuda::std::array<int, 10>,
+                                          cuda::std::array<double, 10> >());
+} // namespace standard_types
+
+namespace types_fit_for_purpose {
+#if TEST_STD_VER > 17
+static_assert(!check_totally_ordered_with<cxx20_member_eq, cxx20_member_eq>());
+static_assert(!check_totally_ordered_with<cxx20_friend_eq, cxx20_friend_eq>());
+static_assert(!check_totally_ordered_with<cxx20_member_eq, cxx20_friend_eq>());
+
+static_assert(check_totally_ordered_with<member_three_way_comparable,
+                                         member_three_way_comparable>());
+static_assert(check_totally_ordered_with<friend_three_way_comparable,
+                                         friend_three_way_comparable>());
+static_assert(!check_totally_ordered_with<member_three_way_comparable,
+                                          friend_three_way_comparable>());
+#endif // TEST_STD_VER > 17
+
+static_assert(
+    check_totally_ordered_with<explicit_operators, explicit_operators>());
+static_assert(!check_totally_ordered_with<equality_comparable_with_ec1,
+                                          equality_comparable_with_ec1>());
+static_assert(check_totally_ordered_with<different_return_types,
+                                         different_return_types>());
+static_assert(!check_totally_ordered_with<explicit_operators,
+                                          equality_comparable_with_ec1>());
+static_assert(
+    check_totally_ordered_with<explicit_operators, different_return_types>());
+
+#if TEST_STD_VER > 17
+static_assert(!check_totally_ordered_with<one_way_eq, one_way_eq>());
+static_assert(
+    cuda::std::common_reference_with<one_way_eq const&, explicit_operators const&> &&
+    !check_totally_ordered_with<one_way_eq, explicit_operators>());
+
+static_assert(!check_totally_ordered_with<one_way_ne, one_way_ne>());
+static_assert(
+    cuda::std::common_reference_with<one_way_ne const&, explicit_operators const&> &&
+    !check_totally_ordered_with<one_way_ne, explicit_operators>());
+
+static_assert(
+    check_totally_ordered_with<totally_ordered_with_others,
+                               partial_ordering_totally_ordered_with>());
+static_assert(check_totally_ordered_with<totally_ordered_with_others,
+                                         weak_ordering_totally_ordered_with>());
+static_assert(
+    check_totally_ordered_with<totally_ordered_with_others,
+                               strong_ordering_totally_ordered_with>());
+
+static_assert(!check_totally_ordered_with<totally_ordered_with_others,
+                                          eq_returns_explicit_bool>());
+static_assert(!check_totally_ordered_with<totally_ordered_with_others,
+                                          ne_returns_explicit_bool>());
+static_assert(equality_comparable_with<totally_ordered_with_others,
+                                            lt_returns_explicit_bool> &&
+              !check_totally_ordered_with<totally_ordered_with_others,
+                                          lt_returns_explicit_bool>());
+static_assert(equality_comparable_with<totally_ordered_with_others,
+                                            gt_returns_explicit_bool> &&
+              !check_totally_ordered_with<totally_ordered_with_others,
+                                          gt_returns_explicit_bool>());
+static_assert(equality_comparable_with<totally_ordered_with_others,
+                                            le_returns_explicit_bool> &&
+              !check_totally_ordered_with<totally_ordered_with_others,
+                                          le_returns_explicit_bool>());
+static_assert(equality_comparable_with<totally_ordered_with_others,
+                                            ge_returns_explicit_bool> &&
+              !check_totally_ordered_with<totally_ordered_with_others,
+                                          ge_returns_explicit_bool>());
+static_assert(check_totally_ordered_with<totally_ordered_with_others,
+                                         returns_true_type>());
+static_assert(
+    check_totally_ordered_with<totally_ordered_with_others, returns_int_ptr>());
+
+static_assert(
+    cuda::std::totally_ordered<no_lt_not_totally_ordered_with>&&
+        equality_comparable_with<totally_ordered_with_others,
+                                      no_lt_not_totally_ordered_with> &&
+    !check_totally_ordered_with<totally_ordered_with_others,
+                                no_lt_not_totally_ordered_with>());
+static_assert(
+    cuda::std::totally_ordered<no_gt_not_totally_ordered_with>&&
+        equality_comparable_with<totally_ordered_with_others,
+                                      no_gt_not_totally_ordered_with> &&
+    !check_totally_ordered_with<totally_ordered_with_others,
+                                no_gt_not_totally_ordered_with>());
+static_assert(
+    cuda::std::totally_ordered<no_le_not_totally_ordered_with>&&
+        equality_comparable_with<totally_ordered_with_others,
+                                      no_le_not_totally_ordered_with> &&
+    !check_totally_ordered_with<totally_ordered_with_others,
+                                no_le_not_totally_ordered_with>());
+static_assert(
+    cuda::std::totally_ordered<no_ge_not_totally_ordered_with>&&
+        equality_comparable_with<totally_ordered_with_others,
+                                      no_ge_not_totally_ordered_with> &&
+    !check_totally_ordered_with<totally_ordered_with_others,
+                                no_ge_not_totally_ordered_with>());
+#endif // TEST_STD_VER > 17
+} // namespace types_fit_for_purpose
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp
new file mode 100644
index 0000000000..6e0c872e56
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp
@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class LHS, class RHS>
+// concept assignable_from =
+//   std::is_lvalue_reference_v<LHS> &&
+//   std::common_reference_with<
+//     const std::remove_reference_t<LHS>&,
+//     const std::remove_reference_t<RHS>&> &&
+//   requires (LHS lhs, RHS&& rhs) {
+//     { lhs = std::forward<RHS>(rhs) } -> std::same_as<LHS>;
+//   };
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "MoveOnly.h"
+
+using namespace cuda::std;
+
+struct NoCommonRef {
+  NoCommonRef& operator=(const int&);
+};
+static_assert(cuda::std::is_assignable_v<NoCommonRef&, const int&>);
+static_assert(!assignable_from<NoCommonRef&, const int&>); // no common reference type
+
+struct Base {};
+struct Derived : Base {};
+static_assert(!assignable_from<Base*, Derived*>);
+static_assert( assignable_from<Base*&, Derived*>);
+static_assert( assignable_from<Base*&, Derived*&>);
+static_assert( assignable_from<Base*&, Derived*&&>);
+static_assert( assignable_from<Base*&, Derived* const>);
+static_assert( assignable_from<Base*&, Derived* const&>);
+static_assert( assignable_from<Base*&, Derived* const&&>);
+static_assert(!assignable_from<Base*&, const Derived*>);
+static_assert(!assignable_from<Base*&, const Derived*&>);
+static_assert(!assignable_from<Base*&, const Derived*&&>);
+static_assert(!assignable_from<Base*&, const Derived* const>);
+static_assert(!assignable_from<Base*&, const Derived* const&>);
+static_assert(!assignable_from<Base*&, const Derived* const&&>);
+static_assert( assignable_from<const Base*&, Derived*>);
+static_assert( assignable_from<const Base*&, Derived*&>);
+static_assert( assignable_from<const Base*&, Derived*&&>);
+static_assert( assignable_from<const Base*&, Derived* const>);
+static_assert( assignable_from<const Base*&, Derived* const&>);
+static_assert( assignable_from<const Base*&, Derived* const&&>);
+static_assert( assignable_from<const Base*&, const Derived*>);
+static_assert( assignable_from<const Base*&, const Derived*&>);
+static_assert( assignable_from<const Base*&, const Derived*&&>);
+static_assert( assignable_from<const Base*&, const Derived* const>);
+static_assert( assignable_from<const Base*&, const Derived* const&>);
+static_assert( assignable_from<const Base*&, const Derived* const&&>);
+
+struct VoidResultType {
+    void operator=(const VoidResultType&);
+};
+static_assert(cuda::std::is_assignable_v<VoidResultType&, const VoidResultType&>);
+
+#if 0
+static_assert(cuda::std::is_same_v<void, _Ret<VoidResultType&, const VoidResultType&>>);
+static_assert(!assignable_from<VoidResultType&, const VoidResultType&>);
+
+struct ValueResultType {
+    ValueResultType operator=(const ValueResultType&);
+};
+static_assert(cuda::std::is_assignable_v<ValueResultType&, const ValueResultType&>);
+static_assert(!assignable_from<ValueResultType&, const ValueResultType&>);
+
+struct Locale {
+    const Locale& operator=(const Locale&);
+};
+static_assert(cuda::std::is_assignable_v<Locale&, const Locale&>);
+static_assert(!assignable_from<Locale&, const Locale&>);
+
+struct Tuple {
+    Tuple& operator=(const Tuple&);
+    const Tuple& operator=(const Tuple&) const;
+};
+static_assert(!assignable_from<Tuple, const Tuple&>);
+static_assert( assignable_from<Tuple&, const Tuple&>);
+static_assert(!assignable_from<Tuple&&, const Tuple&>);
+static_assert(!assignable_from<const Tuple, const Tuple&>);
+static_assert( assignable_from<const Tuple&, const Tuple&>);
+static_assert(!assignable_from<const Tuple&&, const Tuple&>);
+
+// Finally, check a few simple cases.
+static_assert( assignable_from<int&, int>);
+static_assert( assignable_from<int&, int&>);
+static_assert( assignable_from<int&, int&&>);
+static_assert(!assignable_from<const int&, int>);
+static_assert(!assignable_from<const int&, int&>);
+static_assert(!assignable_from<const int&, int&&>);
+static_assert( assignable_from<volatile int&, int>);
+static_assert( assignable_from<volatile int&, int&>);
+static_assert( assignable_from<volatile int&, int&&>);
+static_assert(!assignable_from<int(&)[10], int>);
+static_assert(!assignable_from<int(&)[10], int(&)[10]>);
+static_assert( assignable_from<MoveOnly&, MoveOnly>);
+static_assert(!assignable_from<MoveOnly&, MoveOnly&>);
+static_assert( assignable_from<MoveOnly&, MoveOnly&&>);
+static_assert(!assignable_from<void, int>);
+static_assert(!assignable_from<void, void>);
+#endif
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.common/common_with.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.common/common_with.compile.pass.cpp
new file mode 100644
index 0000000000..b00d5dc017
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.common/common_with.compile.pass.cpp
@@ -0,0 +1,1021 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class From, class To>
+// concept common_with;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "test_macros.h"
+
+using cuda::std::common_with;
+
+template <class T, class U>
+__host__ __device__
+constexpr bool CheckCommonWith() noexcept {
+  constexpr bool result = cuda::std::common_with<T, U>;
+  static_assert(cuda::std::common_with<T, U&> == result);
+  static_assert(cuda::std::common_with<T, const U&> == result);
+  static_assert(cuda::std::common_with<T, volatile U&> == result);
+  static_assert(cuda::std::common_with<T, const volatile U&> == result);
+  static_assert(cuda::std::common_with<T, U&&> == result);
+  static_assert(cuda::std::common_with<T, const U&&> == result);
+  static_assert(cuda::std::common_with<T, volatile U&&> == result);
+  static_assert(cuda::std::common_with<T, const volatile U&&> == result);
+  static_assert(cuda::std::common_with<T&, U&&> == result);
+  static_assert(cuda::std::common_with<T&, const U&&> == result);
+  static_assert(cuda::std::common_with<T&, volatile U&&> == result);
+  static_assert(cuda::std::common_with<T&, const volatile U&&> == result);
+  static_assert(cuda::std::common_with<const T&, U&&> == result);
+  static_assert(cuda::std::common_with<const T&, const U&&> == result);
+  static_assert(cuda::std::common_with<const T&, volatile U&&> == result);
+  static_assert(cuda::std::common_with<const T&, const volatile U&&> == result);
+  static_assert(cuda::std::common_with<volatile T&, U&&> == result);
+  static_assert(cuda::std::common_with<volatile T&, const U&&> == result);
+  static_assert(cuda::std::common_with<volatile T&, volatile U&&> == result);
+  static_assert(cuda::std::common_with<volatile T&, const volatile U&&> == result);
+  static_assert(cuda::std::common_with<const volatile T&, U&&> == result);
+  static_assert(cuda::std::common_with<const volatile T&, const U&&> == result);
+  static_assert(cuda::std::common_with<const volatile T&, volatile U&&> == result);
+  static_assert(cuda::std::common_with<const volatile T&, const volatile U&&> ==
+                result);
+  return result;
+}
+
+template <class T, class U>
+constexpr bool HasValidCommonType() noexcept {
+#if TEST_STD_VER > 17
+  return requires { typename cuda::std::common_type_t<T, U>; }
+#else
+return cuda::std::_Common_type_exists<T, U>
+#endif
+  && std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T> >;
+}
+
+namespace BuiltinTypes {
+// fundamental types
+static_assert(cuda::std::common_with<void, void>);
+static_assert(CheckCommonWith<int, int>());
+static_assert(CheckCommonWith<int, long>());
+static_assert(CheckCommonWith<int, unsigned char>());
+#ifndef TEST_HAS_NO_INT128
+static_assert(CheckCommonWith<int, __int128_t>());
+#endif
+static_assert(CheckCommonWith<int, double>());
+
+// arrays
+static_assert(CheckCommonWith<int[5], int[5]>());
+
+// pointers
+static_assert(CheckCommonWith<int*, int*>());
+static_assert(CheckCommonWith<int*, const int*>());
+static_assert(CheckCommonWith<int*, volatile int*>());
+static_assert(CheckCommonWith<int*, const volatile int*>());
+static_assert(CheckCommonWith<const int*, const int*>());
+static_assert(CheckCommonWith<const int*, volatile int*>());
+static_assert(CheckCommonWith<const int*, const volatile int*>());
+static_assert(CheckCommonWith<volatile int*, const int*>());
+static_assert(CheckCommonWith<volatile int*, volatile int*>());
+static_assert(CheckCommonWith<volatile int*, const volatile int*>());
+static_assert(CheckCommonWith<const volatile int*, const int*>());
+static_assert(CheckCommonWith<const volatile int*, volatile int*>());
+static_assert(CheckCommonWith<const volatile int*, const volatile int*>());
+
+static_assert(CheckCommonWith<int (*)(), int (*)()>());
+static_assert(CheckCommonWith<int (*)(), int (*)() noexcept>());
+#if TEST_STD_VER > 17
+static_assert(CheckCommonWith<int (&)(), int (&)()>());
+static_assert(CheckCommonWith<int (&)(), int (&)() noexcept>());
+#endif // TEST_STD_VER > 17
+static_assert(CheckCommonWith<int (&)(), int (*)()>());
+static_assert(CheckCommonWith<int (&)(), int (*)() noexcept>());
+
+struct S {};
+static_assert(CheckCommonWith<int S::*, int S::*>());
+static_assert(CheckCommonWith<int S::*, const int S::*>());
+static_assert(CheckCommonWith<int (S::*)(), int (S::*)()>());
+static_assert(CheckCommonWith<int (S::*)(), int (S::*)() noexcept>());
+static_assert(CheckCommonWith<int (S::*)() const, int (S::*)() const>());
+static_assert(
+    CheckCommonWith<int (S::*)() const, int (S::*)() const noexcept>());
+static_assert(CheckCommonWith<int (S::*)() volatile, int (S::*)() volatile>());
+static_assert(
+    CheckCommonWith<int (S::*)() volatile, int (S::*)() volatile noexcept>());
+static_assert(CheckCommonWith<int (S::*)() const volatile,
+                              int (S::*)() const volatile>());
+static_assert(CheckCommonWith<int (S::*)() const volatile,
+                              int (S::*)() const volatile noexcept>());
+
+// nonsense
+static_assert(!CheckCommonWith<double, float*>());
+static_assert(!CheckCommonWith<int, int[5]>());
+static_assert(!CheckCommonWith<int*, long*>());
+static_assert(!CheckCommonWith<int*, unsigned int*>());
+static_assert(!CheckCommonWith<int (*)(), int (*)(int)>());
+static_assert(!CheckCommonWith<int S::*, float S::*>());
+static_assert(!CheckCommonWith<int (S::*)(), int (S::*)() const>());
+static_assert(!CheckCommonWith<int (S::*)(), int (S::*)() volatile>());
+static_assert(!CheckCommonWith<int (S::*)(), int (S::*)() const volatile>());
+static_assert(!CheckCommonWith<int (S::*)() const, int (S::*)() volatile>());
+static_assert(
+    !CheckCommonWith<int (S::*)() const, int (S::*)() const volatile>());
+static_assert(
+    !CheckCommonWith<int (S::*)() volatile, int (S::*)() const volatile>());
+} // namespace BuiltinTypes
+
+namespace NoDefaultCommonType {
+class T {};
+
+static_assert(!CheckCommonWith<T, int>());
+static_assert(!CheckCommonWith<int, T>());
+static_assert(!CheckCommonWith<T, int[10]>());
+static_assert(!CheckCommonWith<T[10], int>());
+static_assert(!CheckCommonWith<T*, int*>());
+static_assert(!CheckCommonWith<T*, const int*>());
+static_assert(!CheckCommonWith<T*, volatile int*>());
+static_assert(!CheckCommonWith<T*, const volatile int*>());
+static_assert(!CheckCommonWith<const T*, int*>());
+static_assert(!CheckCommonWith<volatile T*, int*>());
+static_assert(!CheckCommonWith<const volatile T*, int*>());
+static_assert(!CheckCommonWith<const T*, const int*>());
+static_assert(!CheckCommonWith<const T*, volatile int*>());
+static_assert(!CheckCommonWith<const T*, const volatile int*>());
+static_assert(!CheckCommonWith<const T*, const int*>());
+static_assert(!CheckCommonWith<volatile T*, const int*>());
+static_assert(!CheckCommonWith<const volatile T*, const int*>());
+static_assert(!CheckCommonWith<volatile T*, const int*>());
+static_assert(!CheckCommonWith<volatile T*, volatile int*>());
+static_assert(!CheckCommonWith<volatile T*, const volatile int*>());
+static_assert(!CheckCommonWith<const T*, volatile int*>());
+static_assert(!CheckCommonWith<volatile T*, volatile int*>());
+static_assert(!CheckCommonWith<const volatile T*, volatile int*>());
+static_assert(!CheckCommonWith<const volatile T*, const int*>());
+static_assert(!CheckCommonWith<const volatile T*, volatile int*>());
+static_assert(!CheckCommonWith<const volatile T*, const volatile int*>());
+static_assert(!CheckCommonWith<const T*, const volatile int*>());
+static_assert(!CheckCommonWith<volatile T*, const volatile int*>());
+static_assert(!CheckCommonWith<const volatile T*, const volatile int*>());
+static_assert(!CheckCommonWith<T&, int&>());
+static_assert(!CheckCommonWith<T&, const int&>());
+static_assert(!CheckCommonWith<T&, volatile int&>());
+static_assert(!CheckCommonWith<T&, const volatile int&>());
+static_assert(!CheckCommonWith<const T&, int&>());
+static_assert(!CheckCommonWith<volatile T&, int&>());
+static_assert(!CheckCommonWith<const volatile T&, int&>());
+static_assert(!CheckCommonWith<const T&, const int&>());
+static_assert(!CheckCommonWith<const T&, volatile int&>());
+static_assert(!CheckCommonWith<const T&, const volatile int&>());
+static_assert(!CheckCommonWith<const T&, const int&>());
+static_assert(!CheckCommonWith<volatile T&, const int&>());
+static_assert(!CheckCommonWith<const volatile T&, const int&>());
+static_assert(!CheckCommonWith<volatile T&, const int&>());
+static_assert(!CheckCommonWith<volatile T&, volatile int&>());
+static_assert(!CheckCommonWith<volatile T&, const volatile int&>());
+static_assert(!CheckCommonWith<const T&, volatile int&>());
+static_assert(!CheckCommonWith<volatile T&, volatile int&>());
+static_assert(!CheckCommonWith<const volatile T&, volatile int&>());
+static_assert(!CheckCommonWith<const volatile T&, const int&>());
+static_assert(!CheckCommonWith<const volatile T&, volatile int&>());
+static_assert(!CheckCommonWith<const volatile T&, const volatile int&>());
+static_assert(!CheckCommonWith<const T&, const volatile int&>());
+static_assert(!CheckCommonWith<volatile T&, const volatile int&>());
+static_assert(!CheckCommonWith<const volatile T&, const volatile int&>());
+static_assert(!CheckCommonWith<T&, int&&>());
+static_assert(!CheckCommonWith<T&, const int&&>());
+static_assert(!CheckCommonWith<T&, volatile int&&>());
+static_assert(!CheckCommonWith<T&, const volatile int&&>());
+static_assert(!CheckCommonWith<const T&, int&&>());
+static_assert(!CheckCommonWith<volatile T&, int&&>());
+static_assert(!CheckCommonWith<const volatile T&, int&&>());
+static_assert(!CheckCommonWith<const T&, const int&&>());
+static_assert(!CheckCommonWith<const T&, volatile int&&>());
+static_assert(!CheckCommonWith<const T&, const volatile int&&>());
+static_assert(!CheckCommonWith<const T&, const int&&>());
+static_assert(!CheckCommonWith<volatile T&, const int&&>());
+static_assert(!CheckCommonWith<const volatile T&, const int&&>());
+static_assert(!CheckCommonWith<volatile T&, const int&&>());
+static_assert(!CheckCommonWith<volatile T&, volatile int&&>());
+static_assert(!CheckCommonWith<volatile T&, const volatile int&&>());
+static_assert(!CheckCommonWith<const T&, volatile int&&>());
+static_assert(!CheckCommonWith<volatile T&, volatile int&&>());
+static_assert(!CheckCommonWith<const volatile T&, volatile int&&>());
+static_assert(!CheckCommonWith<const volatile T&, const int&&>());
+static_assert(!CheckCommonWith<const volatile T&, volatile int&&>());
+static_assert(!CheckCommonWith<const volatile T&, const volatile int&&>());
+static_assert(!CheckCommonWith<const T&, const volatile int&&>());
+static_assert(!CheckCommonWith<volatile T&, const volatile int&&>());
+static_assert(!CheckCommonWith<const volatile T&, const volatile int&&>());
+static_assert(!CheckCommonWith<T&&, int&>());
+static_assert(!CheckCommonWith<T&&, const int&>());
+static_assert(!CheckCommonWith<T&&, volatile int&>());
+static_assert(!CheckCommonWith<T&&, const volatile int&>());
+static_assert(!CheckCommonWith<const T&&, int&>());
+static_assert(!CheckCommonWith<volatile T&&, int&>());
+static_assert(!CheckCommonWith<const volatile T&&, int&>());
+static_assert(!CheckCommonWith<const T&&, const int&>());
+static_assert(!CheckCommonWith<const T&&, volatile int&>());
+static_assert(!CheckCommonWith<const T&&, const volatile int&>());
+static_assert(!CheckCommonWith<const T&&, const int&>());
+static_assert(!CheckCommonWith<volatile T&&, const int&>());
+static_assert(!CheckCommonWith<const volatile T&&, const int&>());
+static_assert(!CheckCommonWith<volatile T&&, const int&>());
+static_assert(!CheckCommonWith<volatile T&&, volatile int&>());
+static_assert(!CheckCommonWith<volatile T&&, const volatile int&>());
+static_assert(!CheckCommonWith<const T&&, volatile int&>());
+static_assert(!CheckCommonWith<volatile T&&, volatile int&>());
+static_assert(!CheckCommonWith<const volatile T&&, volatile int&>());
+static_assert(!CheckCommonWith<const volatile T&&, const int&>());
+static_assert(!CheckCommonWith<const volatile T&&, volatile int&>());
+static_assert(!CheckCommonWith<const volatile T&&, const volatile int&>());
+static_assert(!CheckCommonWith<const T&&, const volatile int&>());
+static_assert(!CheckCommonWith<volatile T&&, const volatile int&>());
+static_assert(!CheckCommonWith<const volatile T&&, const volatile int&>());
+static_assert(!CheckCommonWith<T&&, int&&>());
+static_assert(!CheckCommonWith<T&&, const int&&>());
+static_assert(!CheckCommonWith<T&&, volatile int&&>());
+static_assert(!CheckCommonWith<T&&, const volatile int&&>());
+static_assert(!CheckCommonWith<const T&&, int&&>());
+static_assert(!CheckCommonWith<volatile T&&, int&&>());
+static_assert(!CheckCommonWith<const volatile T&&, int&&>());
+static_assert(!CheckCommonWith<const T&&, const int&&>());
+static_assert(!CheckCommonWith<const T&&, volatile int&&>());
+static_assert(!CheckCommonWith<const T&&, const volatile int&&>());
+static_assert(!CheckCommonWith<const T&&, const int&&>());
+static_assert(!CheckCommonWith<volatile T&&, const int&&>());
+static_assert(!CheckCommonWith<const volatile T&&, const int&&>());
+static_assert(!CheckCommonWith<volatile T&&, const int&&>());
+static_assert(!CheckCommonWith<volatile T&&, volatile int&&>());
+static_assert(!CheckCommonWith<volatile T&&, const volatile int&&>());
+static_assert(!CheckCommonWith<const T&&, volatile int&&>());
+static_assert(!CheckCommonWith<volatile T&&, volatile int&&>());
+static_assert(!CheckCommonWith<const volatile T&&, volatile int&&>());
+static_assert(!CheckCommonWith<const volatile T&&, const int&&>());
+static_assert(!CheckCommonWith<const volatile T&&, volatile int&&>());
+static_assert(!CheckCommonWith<const volatile T&&, const volatile int&&>());
+static_assert(!CheckCommonWith<const T&&, const volatile int&&>());
+static_assert(!CheckCommonWith<volatile T&&, const volatile int&&>());
+static_assert(!CheckCommonWith<const volatile T&&, const volatile int&&>());
+} // namespace NoDefaultCommonType
+
+struct BadBasicCommonType {
+  // This test is ill-formed, NDR. If it ever blows up in our faces: that's a good thing.
+  // In the meantime, the test should be included. If compiler support is added, then an include guard
+  // should be placed so the test doesn't get deleted.
+};
+
+namespace cuda {
+namespace std {
+template <>
+struct common_type<BadBasicCommonType, int> {
+  using type = BadBasicCommonType;
+};
+
+template <>
+struct common_type<int, BadBasicCommonType> {
+  using type = int;
+};
+} // namespace std
+} // namespace cuda
+static_assert(cuda::std::_Common_type_exists<BadBasicCommonType, int>);
+static_assert(cuda::std::_Common_type_exists<int, BadBasicCommonType>);
+static_assert(!cuda::std::same_as<cuda::std::common_type_t<BadBasicCommonType, int>,
+                            cuda::std::common_type_t<int, BadBasicCommonType> >);
+static_assert(!CheckCommonWith<BadBasicCommonType, int>());
+
+struct DullCommonType {};
+static_assert(!cuda::std::convertible_to<DullCommonType, int>);
+
+struct T1 {};
+static_assert(!cuda::std::convertible_to<DullCommonType, T1>);
+
+namespace cuda {
+namespace std {
+template <>
+struct common_type<T1, int> {
+  using type = DullCommonType;
+};
+
+template <>
+struct common_type<int, T1> {
+  using type = DullCommonType;
+};
+} // namespace std
+} // namespace cuda
+static_assert(cuda::std::_Common_type_exists<T1, int>);
+static_assert(cuda::std::_Common_type_exists<T1, int>);
+static_assert(cuda::std::same_as<cuda::std::common_type_t<T1, int>, DullCommonType>);
+static_assert(cuda::std::same_as<cuda::std::common_type_t<int, T1>, DullCommonType>);
+static_assert(HasValidCommonType<T1, int>());
+static_assert(!CheckCommonWith<T1, int>());
+
+#if TEST_STD_VER > 17
+struct CommonTypeImplicitlyConstructibleFromInt {
+  explicit(false) CommonTypeImplicitlyConstructibleFromInt(int);
+};
+static_assert(requires {
+  static_cast<CommonTypeImplicitlyConstructibleFromInt>(0);
+});
+
+struct T2 {};
+static_assert(
+    !cuda::std::convertible_to<CommonTypeImplicitlyConstructibleFromInt, T2>);
+
+namespace cuda {
+namespace std {
+template <>
+struct common_type<T2, int> {
+  using type = CommonTypeImplicitlyConstructibleFromInt;
+};
+
+template <>
+struct common_type<int, T2> {
+  using type = CommonTypeImplicitlyConstructibleFromInt;
+};
+} // namespace std
+} // namespace cuda
+static_assert(HasValidCommonType<T2, int>());
+static_assert(!CheckCommonWith<T2, int>());
+
+struct CommonTypeExplicitlyConstructibleFromInt {
+  explicit CommonTypeExplicitlyConstructibleFromInt(int);
+};
+static_assert(requires {
+  static_cast<CommonTypeExplicitlyConstructibleFromInt>(0);
+});
+
+struct T3 {};
+static_assert(
+    !cuda::std::convertible_to<CommonTypeExplicitlyConstructibleFromInt, T2>);
+
+namespace cuda {
+namespace std {
+template <>
+struct common_type<T3, int> {
+  using type = CommonTypeExplicitlyConstructibleFromInt;
+};
+
+template <>
+struct common_type<int, T3> {
+  using type = CommonTypeExplicitlyConstructibleFromInt;
+};
+} // namespace std
+} // namespace cuda
+static_assert(HasValidCommonType<T3, int>());
+static_assert(!CheckCommonWith<T3, int>());
+
+struct T4 {};
+struct CommonTypeImplicitlyConstructibleFromT4 {
+  explicit(false) CommonTypeImplicitlyConstructibleFromT4(T4);
+};
+static_assert(requires(T4 t4) {
+  static_cast<CommonTypeImplicitlyConstructibleFromT4>(t4);
+});
+
+namespace cuda {
+namespace std {
+template <>
+struct common_type<T4, int> {
+  using type = CommonTypeImplicitlyConstructibleFromT4;
+};
+
+template <>
+struct common_type<int, T4> {
+  using type = CommonTypeImplicitlyConstructibleFromT4;
+};
+} // namespace std
+} // namespace cuda
+static_assert(HasValidCommonType<T4, int>());
+static_assert(!CheckCommonWith<T4, int>());
+
+struct T5 {};
+struct CommonTypeExplicitlyConstructibleFromT5 {
+  explicit CommonTypeExplicitlyConstructibleFromT5(T5);
+};
+static_assert(requires(T5 t5) {
+  static_cast<CommonTypeExplicitlyConstructibleFromT5>(t5);
+});
+
+namespace cuda {
+namespace std {
+template <>
+struct common_type<T5, int> {
+  using type = CommonTypeExplicitlyConstructibleFromT5;
+};
+
+template <>
+struct common_type<int, T5> {
+  using type = CommonTypeExplicitlyConstructibleFromT5;
+};
+} // namespace std
+} // namespace cuda
+static_assert(HasValidCommonType<T5, int>());
+static_assert(!CheckCommonWith<T5, int>());
+#endif // TEST_STD_VER > 17
+
+struct T6 {};
+struct CommonTypeNoCommonReference {
+  CommonTypeNoCommonReference(T6);
+  CommonTypeNoCommonReference(int);
+};
+
+namespace cuda {
+namespace std {
+template <>
+struct common_type<T6, int> {
+  using type = CommonTypeNoCommonReference;
+};
+
+template <>
+struct common_type<int, T6> {
+  using type = CommonTypeNoCommonReference;
+};
+
+template <>
+struct common_type<T6&, int&> {};
+
+template <>
+struct common_type<int&, T6&> {};
+
+template <>
+struct common_type<T6&, const int&> {};
+
+template <>
+struct common_type<int&, const T6&> {};
+
+template <>
+struct common_type<T6&, volatile int&> {};
+
+template <>
+struct common_type<int&, volatile T6&> {};
+
+template <>
+struct common_type<T6&, const volatile int&> {};
+
+template <>
+struct common_type<int&, const volatile T6&> {};
+
+template <>
+struct common_type<const T6&, int&> {};
+
+template <>
+struct common_type<const int&, T6&> {};
+
+template <>
+struct common_type<const T6&, const int&> {};
+
+template <>
+struct common_type<const int&, const T6&> {};
+
+template <>
+struct common_type<const T6&, volatile int&> {};
+
+template <>
+struct common_type<const int&, volatile T6&> {};
+
+template <>
+struct common_type<const T6&, const volatile int&> {};
+
+template <>
+struct common_type<const int&, const volatile T6&> {};
+
+template <>
+struct common_type<volatile T6&, int&> {};
+
+template <>
+struct common_type<volatile int&, T6&> {};
+
+template <>
+struct common_type<volatile T6&, const int&> {};
+
+template <>
+struct common_type<volatile int&, const T6&> {};
+
+template <>
+struct common_type<volatile T6&, volatile int&> {};
+
+template <>
+struct common_type<volatile int&, volatile T6&> {};
+
+template <>
+struct common_type<volatile T6&, const volatile int&> {};
+
+template <>
+struct common_type<volatile int&, const volatile T6&> {};
+
+template <>
+struct common_type<const volatile T6&, int&> {};
+
+template <>
+struct common_type<const volatile int&, T6&> {};
+
+template <>
+struct common_type<const volatile T6&, const int&> {};
+
+template <>
+struct common_type<const volatile int&, const T6&> {};
+
+template <>
+struct common_type<const volatile T6&, volatile int&> {};
+
+template <>
+struct common_type<const volatile int&, volatile T6&> {};
+
+template <>
+struct common_type<const volatile T6&, const volatile int&> {};
+
+template <>
+struct common_type<const volatile int&, const volatile T6&> {};
+} // namespace std
+} // namespace cuda
+
+template <typename T, typename U>
+constexpr bool HasCommonReference() noexcept {
+  return cuda::std::_Common_reference_exists<T, U>;
+}
+
+static_assert(HasValidCommonType<T6, int>());
+static_assert(!HasCommonReference<const T6&, const int&>());
+static_assert(!CheckCommonWith<T6, int>());
+
+struct T7 {};
+struct CommonTypeNoMetaCommonReference {
+  CommonTypeNoMetaCommonReference(T7);
+  CommonTypeNoMetaCommonReference(int);
+};
+
+namespace cuda {
+namespace std {
+template <>
+struct common_type<T7, int> {
+  using type = CommonTypeNoMetaCommonReference;
+};
+
+template <>
+struct common_type<int, T7> {
+  using type = CommonTypeNoMetaCommonReference;
+};
+
+template <>
+struct common_type<T7&, int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<int&, T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<T7&, const int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<int&, const T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<T7&, volatile int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<int&, volatile T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<T7&, const volatile int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<int&, const volatile T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const T7&, int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const int&, T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const T7&, const int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const int&, const T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const T7&, volatile int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const int&, volatile T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const T7&, const volatile int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const int&, const volatile T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<volatile T7&, int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<volatile int&, T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<volatile T7&, const int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<volatile int&, const T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<volatile T7&, volatile int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<volatile int&, volatile T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<volatile T7&, const volatile int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<volatile int&, const volatile T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const volatile T7&, int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const volatile int&, T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const volatile T7&, const int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const volatile int&, const T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const volatile T7&, volatile int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const volatile int&, volatile T7&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const volatile T7&, const volatile int&> {
+  using type = void;
+};
+
+template <>
+struct common_type<const volatile int&, const volatile T7&> {
+  using type = void;
+};
+} // namespace std
+} // namespace cuda
+static_assert(HasValidCommonType<T7, int>());
+static_assert(HasValidCommonType<const T7&, const int&>());
+static_assert(HasCommonReference<const T7&, const int&>());
+static_assert(
+    !HasCommonReference<cuda::std::common_type_t<T7, int>&,
+                        cuda::std::common_reference_t<const T7&, const int&> >());
+static_assert(!CheckCommonWith<T7, int>());
+
+struct CommonWithInt {
+  operator int() const volatile;
+};
+
+namespace std {
+template <>
+struct common_type<CommonWithInt, int> {
+  using type = int;
+};
+
+template <>
+struct common_type<int, CommonWithInt> : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<CommonWithInt&, int&> : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<int&, CommonWithInt&> : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<CommonWithInt&, const int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<int&, const CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<CommonWithInt&, volatile int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<int&, volatile CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<CommonWithInt&, const volatile int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<int&, const volatile CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const CommonWithInt&, int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const int&, CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const CommonWithInt&, const int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const int&, const CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const CommonWithInt&, volatile int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const int&, volatile CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const CommonWithInt&, const volatile int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const int&, const volatile CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<volatile CommonWithInt&, int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<volatile int&, CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<volatile CommonWithInt&, const int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<volatile int&, const CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<volatile CommonWithInt&, volatile int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<volatile int&, volatile CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<volatile CommonWithInt&, const volatile int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<volatile int&, const volatile CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const volatile CommonWithInt&, int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const volatile int&, CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const volatile CommonWithInt&, const int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const volatile int&, const CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const volatile CommonWithInt&, volatile int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const volatile int&, volatile CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const volatile CommonWithInt&, const volatile int&>
+    : common_type<CommonWithInt, int> {};
+
+template <>
+struct common_type<const volatile int&, const volatile CommonWithInt&>
+    : common_type<CommonWithInt, int> {};
+} // namespace std
+static_assert(CheckCommonWith<CommonWithInt, int>());
+
+struct CommonWithIntButRefLong {
+  operator int() const volatile;
+};
+
+namespace std {
+template <>
+struct common_type<CommonWithIntButRefLong, int> {
+  using type = int;
+};
+
+template <>
+struct common_type<int, CommonWithIntButRefLong>
+    : common_type<CommonWithIntButRefLong, int> {};
+
+template <>
+struct common_type<CommonWithIntButRefLong&, int&> {
+  using type = long;
+};
+
+template <>
+struct common_type<int&, CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<CommonWithIntButRefLong&, const int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<int&, const CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<CommonWithIntButRefLong&, volatile int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<int&, volatile CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<CommonWithIntButRefLong&, const volatile int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<int&, const volatile CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const CommonWithIntButRefLong&, int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const int&, CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const CommonWithIntButRefLong&, const int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const int&, const CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const CommonWithIntButRefLong&, volatile int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const int&, volatile CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const CommonWithIntButRefLong&, const volatile int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const int&, const volatile CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<volatile CommonWithIntButRefLong&, int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<volatile int&, CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<volatile CommonWithIntButRefLong&, const int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<volatile int&, const CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<volatile CommonWithIntButRefLong&, volatile int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<volatile int&, volatile CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<volatile CommonWithIntButRefLong&, const volatile int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<volatile int&, const volatile CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const volatile CommonWithIntButRefLong&, int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const volatile int&, CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const volatile CommonWithIntButRefLong&, const int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const volatile int&, const CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const volatile CommonWithIntButRefLong&, volatile int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const volatile int&, volatile CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const volatile CommonWithIntButRefLong&, const volatile int&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+
+template <>
+struct common_type<const volatile int&, const volatile CommonWithIntButRefLong&>
+    : common_type<CommonWithIntButRefLong&, int&> {};
+} // namespace std
+static_assert(CheckCommonWith<CommonWithIntButRefLong, int>());
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.commonref/common_reference.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.commonref/common_reference.compile.pass.cpp
new file mode 100644
index 0000000000..707ae7ca58
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.commonref/common_reference.compile.pass.cpp
@@ -0,0 +1,376 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class From, class To>
+// concept common_reference_with;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "test_macros.h"
+
+using cuda::std::common_reference_with;
+
+template <class T, class U>
+__host__ __device__
+constexpr bool CheckCommonReferenceWith() noexcept {
+  static_assert(common_reference_with<T, U&>);
+  static_assert(common_reference_with<T, const U&>);
+  static_assert(common_reference_with<T, volatile U&>);
+  static_assert(common_reference_with<T, const volatile U&>);
+  static_assert(common_reference_with<T, U&&>);
+  static_assert(common_reference_with<T, const U&&>);
+  static_assert(common_reference_with<T, volatile U&&>);
+  static_assert(common_reference_with<T, const volatile U&&>);
+  static_assert(common_reference_with<T&, U&&>);
+  static_assert(common_reference_with<T&, const U&&>);
+  static_assert(common_reference_with<T&, volatile U&&>);
+  static_assert(common_reference_with<T&, const volatile U&&>);
+  static_assert(common_reference_with<const T&, U&&>);
+  static_assert(common_reference_with<const T&, const U&&>);
+  static_assert(common_reference_with<const T&, volatile U&&>);
+  static_assert(common_reference_with<const T&, const volatile U&&>);
+  static_assert(common_reference_with<volatile T&, U&&>);
+  static_assert(common_reference_with<volatile T&, const U&&>);
+  static_assert(common_reference_with<volatile T&, volatile U&&>);
+  static_assert(common_reference_with<volatile T&, const volatile U&&>);
+  static_assert(common_reference_with<const volatile T&, U&&>);
+  static_assert(common_reference_with<const volatile T&, const U&&>);
+  static_assert(common_reference_with<const volatile T&, volatile U&&>);
+  static_assert(
+      common_reference_with<const volatile T&, const volatile U&&>);
+
+  return common_reference_with<T, U>;
+}
+
+namespace BuiltinTypes {
+// fundamental types
+static_assert(common_reference_with<void, void>);
+static_assert(CheckCommonReferenceWith<int, int>());
+static_assert(CheckCommonReferenceWith<int, long>());
+static_assert(CheckCommonReferenceWith<int, unsigned char>());
+#ifndef TEST_HAS_NO_INT128
+static_assert(CheckCommonReferenceWith<int, __int128_t>());
+#endif
+static_assert(CheckCommonReferenceWith<int, double>());
+
+// arrays
+static_assert(CheckCommonReferenceWith<int[5], int[5]>());
+
+// pointers (common with void*)
+static_assert(CheckCommonReferenceWith<int*, void*>());
+static_assert(CheckCommonReferenceWith<int*, const void*>());
+static_assert(CheckCommonReferenceWith<int*, volatile void*>());
+static_assert(CheckCommonReferenceWith<int*, const volatile void*>());
+static_assert(CheckCommonReferenceWith<const int*, void*>());
+static_assert(CheckCommonReferenceWith<const int*, const void*>());
+static_assert(CheckCommonReferenceWith<const int*, volatile void*>());
+static_assert(CheckCommonReferenceWith<const int*, const volatile void*>());
+static_assert(CheckCommonReferenceWith<volatile int*, void*>());
+static_assert(CheckCommonReferenceWith<volatile int*, const void*>());
+static_assert(CheckCommonReferenceWith<volatile int*, volatile void*>());
+static_assert(CheckCommonReferenceWith<volatile int*, const volatile void*>());
+static_assert(CheckCommonReferenceWith<const volatile int*, void*>());
+static_assert(CheckCommonReferenceWith<const volatile int*, const void*>());
+static_assert(CheckCommonReferenceWith<const volatile int*, volatile void*>());
+static_assert(
+    CheckCommonReferenceWith<const volatile int*, const volatile void*>());
+
+static_assert(CheckCommonReferenceWith<int (*)(), int (*)()>());
+static_assert(CheckCommonReferenceWith<int (*)(), int (*)() noexcept>());
+struct S {};
+static_assert(CheckCommonReferenceWith<int S::*, int S::*>());
+static_assert(CheckCommonReferenceWith<int S::*, const int S::*>());
+static_assert(CheckCommonReferenceWith<int (S::*)(), int (S::*)()>());
+static_assert(CheckCommonReferenceWith<int (S::*)(), int (S::*)() noexcept>());
+static_assert(
+    CheckCommonReferenceWith<int (S::*)() const, int (S::*)() const>());
+static_assert(CheckCommonReferenceWith<int (S::*)() const,
+                                       int (S::*)() const noexcept>());
+static_assert(
+    CheckCommonReferenceWith<int (S::*)() volatile, int (S::*)() volatile>());
+static_assert(CheckCommonReferenceWith<int (S::*)() volatile,
+                                       int (S::*)() volatile noexcept>());
+static_assert(CheckCommonReferenceWith<int (S::*)() const volatile,
+                                       int (S::*)() const volatile>());
+static_assert(CheckCommonReferenceWith<int (S::*)() const volatile,
+                                       int (S::*)() const volatile noexcept>());
+
+// nonsense
+static_assert(!common_reference_with<double, float*>);
+static_assert(!common_reference_with<int, int[5]>);
+static_assert(!common_reference_with<int*, long*>);
+static_assert(!common_reference_with<int*, unsigned int*>);
+static_assert(!common_reference_with<int (*)(), int (*)(int)>);
+static_assert(!common_reference_with<int S::*, float S::*>);
+static_assert(!common_reference_with<int (S::*)(), int (S::*)() const>);
+static_assert(!common_reference_with<int (S::*)(), int (S::*)() volatile>);
+static_assert(
+    !common_reference_with<int (S::*)(), int (S::*)() const volatile>);
+static_assert(
+    !common_reference_with<int (S::*)() const, int (S::*)() volatile>);
+static_assert(!common_reference_with<int (S::*)() const,
+                                          int (S::*)() const volatile>);
+static_assert(!common_reference_with<int (S::*)() volatile,
+                                          int (S::*)() const volatile>);
+} // namespace BuiltinTypes
+
+namespace NoDefaultCommonReference {
+class T {};
+
+static_assert(!common_reference_with<T, int>);
+static_assert(!common_reference_with<int, T>);
+static_assert(!common_reference_with<T, int[10]>);
+static_assert(!common_reference_with<T[10], int>);
+static_assert(!common_reference_with<T*, int*>);
+static_assert(!common_reference_with<T*, const int*>);
+static_assert(!common_reference_with<T*, volatile int*>);
+static_assert(!common_reference_with<T*, const volatile int*>);
+static_assert(!common_reference_with<const T*, int*>);
+static_assert(!common_reference_with<volatile T*, int*>);
+static_assert(!common_reference_with<const volatile T*, int*>);
+static_assert(!common_reference_with<const T*, const int*>);
+static_assert(!common_reference_with<const T*, volatile int*>);
+static_assert(!common_reference_with<const T*, const volatile int*>);
+static_assert(!common_reference_with<const T*, const int*>);
+static_assert(!common_reference_with<volatile T*, const int*>);
+static_assert(!common_reference_with<const volatile T*, const int*>);
+static_assert(!common_reference_with<volatile T*, const int*>);
+static_assert(!common_reference_with<volatile T*, volatile int*>);
+static_assert(!common_reference_with<volatile T*, const volatile int*>);
+static_assert(!common_reference_with<const T*, volatile int*>);
+static_assert(!common_reference_with<volatile T*, volatile int*>);
+static_assert(!common_reference_with<const volatile T*, volatile int*>);
+static_assert(!common_reference_with<const volatile T*, const int*>);
+static_assert(!common_reference_with<const volatile T*, volatile int*>);
+static_assert(
+    !common_reference_with<const volatile T*, const volatile int*>);
+static_assert(!common_reference_with<const T*, const volatile int*>);
+static_assert(!common_reference_with<volatile T*, const volatile int*>);
+static_assert(
+    !common_reference_with<const volatile T*, const volatile int*>);
+static_assert(!common_reference_with<T&, int&>);
+static_assert(!common_reference_with<T&, const int&>);
+static_assert(!common_reference_with<T&, volatile int&>);
+static_assert(!common_reference_with<T&, const volatile int&>);
+static_assert(!common_reference_with<const T&, int&>);
+static_assert(!common_reference_with<volatile T&, int&>);
+static_assert(!common_reference_with<const volatile T&, int&>);
+static_assert(!common_reference_with<const T&, const int&>);
+static_assert(!common_reference_with<const T&, volatile int&>);
+static_assert(!common_reference_with<const T&, const volatile int&>);
+static_assert(!common_reference_with<const T&, const int&>);
+static_assert(!common_reference_with<volatile T&, const int&>);
+static_assert(!common_reference_with<const volatile T&, const int&>);
+static_assert(!common_reference_with<volatile T&, const int&>);
+static_assert(!common_reference_with<volatile T&, volatile int&>);
+static_assert(!common_reference_with<volatile T&, const volatile int&>);
+static_assert(!common_reference_with<const T&, volatile int&>);
+static_assert(!common_reference_with<volatile T&, volatile int&>);
+static_assert(!common_reference_with<const volatile T&, volatile int&>);
+static_assert(!common_reference_with<const volatile T&, const int&>);
+static_assert(!common_reference_with<const volatile T&, volatile int&>);
+static_assert(
+    !common_reference_with<const volatile T&, const volatile int&>);
+static_assert(!common_reference_with<const T&, const volatile int&>);
+static_assert(!common_reference_with<volatile T&, const volatile int&>);
+static_assert(
+    !common_reference_with<const volatile T&, const volatile int&>);
+static_assert(!common_reference_with<T&, int&&>);
+static_assert(!common_reference_with<T&, const int&&>);
+static_assert(!common_reference_with<T&, volatile int&&>);
+static_assert(!common_reference_with<T&, const volatile int&&>);
+static_assert(!common_reference_with<const T&, int&&>);
+static_assert(!common_reference_with<volatile T&, int&&>);
+static_assert(!common_reference_with<const volatile T&, int&&>);
+static_assert(!common_reference_with<const T&, const int&&>);
+static_assert(!common_reference_with<const T&, volatile int&&>);
+static_assert(!common_reference_with<const T&, const volatile int&&>);
+static_assert(!common_reference_with<const T&, const int&&>);
+static_assert(!common_reference_with<volatile T&, const int&&>);
+static_assert(!common_reference_with<const volatile T&, const int&&>);
+static_assert(!common_reference_with<volatile T&, const int&&>);
+static_assert(!common_reference_with<volatile T&, volatile int&&>);
+static_assert(!common_reference_with<volatile T&, const volatile int&&>);
+static_assert(!common_reference_with<const T&, volatile int&&>);
+static_assert(!common_reference_with<volatile T&, volatile int&&>);
+static_assert(!common_reference_with<const volatile T&, volatile int&&>);
+static_assert(!common_reference_with<const volatile T&, const int&&>);
+static_assert(!common_reference_with<const volatile T&, volatile int&&>);
+static_assert(
+    !common_reference_with<const volatile T&, const volatile int&&>);
+static_assert(!common_reference_with<const T&, const volatile int&&>);
+static_assert(!common_reference_with<volatile T&, const volatile int&&>);
+static_assert(
+    !common_reference_with<const volatile T&, const volatile int&&>);
+static_assert(!common_reference_with<T&&, int&>);
+static_assert(!common_reference_with<T&&, const int&>);
+static_assert(!common_reference_with<T&&, volatile int&>);
+static_assert(!common_reference_with<T&&, const volatile int&>);
+static_assert(!common_reference_with<const T&&, int&>);
+static_assert(!common_reference_with<volatile T&&, int&>);
+static_assert(!common_reference_with<const volatile T&&, int&>);
+static_assert(!common_reference_with<const T&&, const int&>);
+static_assert(!common_reference_with<const T&&, volatile int&>);
+static_assert(!common_reference_with<const T&&, const volatile int&>);
+static_assert(!common_reference_with<const T&&, const int&>);
+static_assert(!common_reference_with<volatile T&&, const int&>);
+static_assert(!common_reference_with<const volatile T&&, const int&>);
+static_assert(!common_reference_with<volatile T&&, const int&>);
+static_assert(!common_reference_with<volatile T&&, volatile int&>);
+static_assert(!common_reference_with<volatile T&&, const volatile int&>);
+static_assert(!common_reference_with<const T&&, volatile int&>);
+static_assert(!common_reference_with<volatile T&&, volatile int&>);
+static_assert(!common_reference_with<const volatile T&&, volatile int&>);
+static_assert(!common_reference_with<const volatile T&&, const int&>);
+static_assert(!common_reference_with<const volatile T&&, volatile int&>);
+static_assert(
+    !common_reference_with<const volatile T&&, const volatile int&>);
+static_assert(!common_reference_with<const T&&, const volatile int&>);
+static_assert(!common_reference_with<volatile T&&, const volatile int&>);
+static_assert(
+    !common_reference_with<const volatile T&&, const volatile int&>);
+static_assert(!common_reference_with<T&&, int&&>);
+static_assert(!common_reference_with<T&&, const int&&>);
+static_assert(!common_reference_with<T&&, volatile int&&>);
+static_assert(!common_reference_with<T&&, const volatile int&&>);
+static_assert(!common_reference_with<const T&&, int&&>);
+static_assert(!common_reference_with<volatile T&&, int&&>);
+static_assert(!common_reference_with<const volatile T&&, int&&>);
+static_assert(!common_reference_with<const T&&, const int&&>);
+static_assert(!common_reference_with<const T&&, volatile int&&>);
+static_assert(!common_reference_with<const T&&, const volatile int&&>);
+static_assert(!common_reference_with<const T&&, const int&&>);
+static_assert(!common_reference_with<volatile T&&, const int&&>);
+static_assert(!common_reference_with<const volatile T&&, const int&&>);
+static_assert(!common_reference_with<volatile T&&, const int&&>);
+static_assert(!common_reference_with<volatile T&&, volatile int&&>);
+static_assert(!common_reference_with<volatile T&&, const volatile int&&>);
+static_assert(!common_reference_with<const T&&, volatile int&&>);
+static_assert(!common_reference_with<volatile T&&, volatile int&&>);
+static_assert(!common_reference_with<const volatile T&&, volatile int&&>);
+static_assert(!common_reference_with<const volatile T&&, const int&&>);
+static_assert(!common_reference_with<const volatile T&&, volatile int&&>);
+static_assert(
+    !common_reference_with<const volatile T&&, const volatile int&&>);
+static_assert(!common_reference_with<const T&&, const volatile int&&>);
+static_assert(!common_reference_with<volatile T&&, const volatile int&&>);
+static_assert(
+    !common_reference_with<const volatile T&&, const volatile int&&>);
+} // namespace NoDefaultCommonReference
+
+
+struct s2 {};
+struct convertible_with_const_s2 {
+  operator s2 const &() const;
+};
+static_assert(common_reference_with<convertible_with_const_s2 const&, s2 const&>);
+
+struct convertible_with_volatile_s2 {
+  operator s2 volatile &() volatile;
+};
+static_assert(common_reference_with<convertible_with_volatile_s2 volatile&, s2 volatile&>);
+
+struct BadBasicCommonReference {
+  // This test is ill-formed, NDR. If it ever blows up in our faces: that's a good thing.
+  // In the meantime, the test should be included. If compiler support is added, then an include guard
+  // should be placed so the test doesn't get deleted.
+  operator int() const;
+  operator int&();
+};
+static_assert(cuda::std::convertible_to<BadBasicCommonReference, int>);
+static_assert(cuda::std::convertible_to<BadBasicCommonReference, int&>);
+
+namespace cuda {
+namespace std {
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<BadBasicCommonReference, int, X, Y> {
+  using type = BadBasicCommonReference&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<int, BadBasicCommonReference, X, Y> {
+  using type = int&;
+};
+} // namespace std
+} // namespace cuda
+static_assert(!common_reference_with<BadBasicCommonReference, int>);
+
+#if TEST_STD_VER > 17
+struct StructNotConvertibleToCommonReference {
+  explicit(false) StructNotConvertibleToCommonReference(int);
+};
+static_assert(cuda::std::convertible_to<int, StructNotConvertibleToCommonReference>);
+
+namespace cuda{
+namespace std {
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<StructNotConvertibleToCommonReference, int, X,
+                              Y> {
+  using type = int&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<int, StructNotConvertibleToCommonReference, X,
+                              Y> {
+  using type = int&;
+};
+} // namespace std
+} // namespace cuda
+static_assert(
+    !common_reference_with<StructNotConvertibleToCommonReference, int>);
+#endif // TEST_STD_VER > 17
+
+struct IntNotConvertibleToCommonReference {
+  operator int&() const;
+};
+
+namespace cuda{
+namespace std {
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<IntNotConvertibleToCommonReference, int, X, Y> {
+  using type = int&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<int, IntNotConvertibleToCommonReference, X, Y> {
+  using type = int&;
+};
+} // namespace std
+} // namespace cuda
+static_assert(
+    !common_reference_with<IntNotConvertibleToCommonReference, int>);
+
+#if TEST_STD_VER > 17
+struct HasCommonReference {
+  explicit(false) HasCommonReference(int);
+  operator int&() const;
+};
+
+namespace cuda{
+namespace std {
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<HasCommonReference, int, X, Y> {
+  using type = int&;
+};
+
+template <template <class> class X, template <class> class Y>
+struct basic_common_reference<int, HasCommonReference, X, Y> {
+  using type = int&;
+};
+} // namespace std
+} // namespace cuda
+
+static_assert(!common_reference_with<HasCommonReference, int>);
+static_assert(common_reference_with<HasCommonReference, int&>);
+#endif // TEST_STD_VER > 17
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp
new file mode 100644
index 0000000000..6bb0146976
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp
@@ -0,0 +1,142 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T, class... Args>
+// concept constructible_from;
+//    destructible<T> && is_constructible_v<T, Args...>;
+
+#include <cuda/std/array>
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+struct Empty {};
+
+struct Defaulted {
+  ~Defaulted() = default;
+};
+struct Deleted {
+  ~Deleted() = delete;
+};
+
+struct Noexcept {
+  ~Noexcept() noexcept;
+};
+struct NoexceptTrue {
+  ~NoexceptTrue() noexcept(true);
+};
+struct NoexceptFalse {
+  ~NoexceptFalse() noexcept(false);
+};
+
+struct Protected {
+protected:
+  ~Protected() = default;
+};
+struct Private {
+private:
+  ~Private() = default;
+};
+
+template <class T>
+struct NoexceptDependant {
+  ~NoexceptDependant() noexcept(cuda::std::is_same_v<T, int>);
+};
+
+template <class T, class... Args>
+void test() {
+  static_assert(cuda::std::constructible_from<T, Args...> ==
+                (cuda::std::destructible<T> && cuda::std::is_constructible_v<T, Args...>));
+}
+
+void test() {
+  test<bool>();
+  test<bool, bool>();
+
+  test<char>();
+  test<char, char>();
+  test<char, int>();
+
+  test<int>();
+  test<int, int>();
+  test<int, int, int>();
+
+  test<double, int>();
+  test<double, float>();
+  test<double, long double>();
+
+  test<void>();
+  test<void, bool>();
+  test<void, int>();
+
+  test<void*>();
+  test<void*, nullptr_t>();
+
+  test<int*>();
+  test<int*, nullptr_t>();
+  test<int[], int, int, int>();
+  test<int[1]>();
+  test<int[1], int>();
+  test<int[1], int, int>();
+
+  test<int (*)(int)>();
+  test<int (*)(int), int>();
+  test<int (*)(int), double>();
+  test<int (*)(int), nullptr_t>();
+  test<int (*)(int), int (*)(int)>();
+
+  test<void (Empty::*)(const int&)>();
+  test<void (Empty::*)(const int&), nullptr_t>();
+  test<void (Empty::*)(const int&) const>();
+  test<void (Empty::*)(const int&) const, void (Empty::*)(const int&)>();
+  test<void (Empty::*)(const int&) volatile>();
+  test<void (Empty::*)(const int&) volatile,
+       void (Empty::*)(const int&) const volatile>();
+  test<void (Empty::*)(const int&) const volatile>();
+  test<void (Empty::*)(const int&) const volatile, double>();
+  test<void (Empty::*)(const int&)&>();
+  test<void (Empty::*)(const int&)&, void (Empty::*)(const int&) &&>();
+  test<void (Empty::*)(const int&) &&>();
+  test<void (Empty::*)(const int&)&&, void (Empty::*)(const int&)>();
+  test<void (Empty::*)(const int&) throw()>();
+  test<void (Empty::*)(const int&) throw(),
+       void(Empty::*)(const int&) noexcept(true)>();
+  test<void (Empty::*)(const int&) noexcept>();
+  test<void (Empty::*)(const int&) noexcept(true)>();
+  test<void (Empty::*)(const int&) noexcept(true),
+       void (Empty::*)(const int&) noexcept(false)>();
+  test<void (Empty::*)(const int&) noexcept(false)>();
+
+  test<int&>();
+  test<int&, int>();
+  test<int&&>();
+  test<int&&, int>();
+
+  test<Empty>();
+
+  test<Defaulted>();
+  test<Deleted>();
+
+  test<NoexceptTrue>();
+  test<NoexceptFalse>();
+  test<Noexcept>();
+
+  test<Protected>();
+  test<Private>();
+
+  test<NoexceptDependant<int> >();
+  test<NoexceptDependant<double> >();
+
+  test<cuda::std::array<int, 1> >();
+  test<cuda::std::array<int, 1>, int>();
+  test<cuda::std::array<int, 1>, int, int>();
+}
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.convertible/convertible_to.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.convertible/convertible_to.pass.cpp
new file mode 100644
index 0000000000..9426785b88
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.convertible/convertible_to.pass.cpp
@@ -0,0 +1,437 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class From, class To>
+// concept convertible_to;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+using cuda::std::convertible_to;
+
+namespace {
+enum ClassicEnum { a, b };
+enum class ScopedEnum { x, y };
+struct Empty {};
+using nullptr_t = decltype(nullptr);
+
+template <class T, class U>
+__host__ __device__
+void CheckConvertibleTo() {
+  static_assert(convertible_to<T, U>);
+  static_assert(convertible_to<const T, U>);
+  static_assert(convertible_to<T, const U>);
+  static_assert(convertible_to<const T, const U>);
+}
+
+template <class T, class U>
+__host__ __device__
+void CheckNotConvertibleTo() {
+  static_assert(!convertible_to<T, U>);
+  static_assert(!convertible_to<const T, U>);
+  static_assert(!convertible_to<T, const U>);
+  static_assert(!convertible_to<const T, const U>);
+}
+
+template <class T, class U>
+__host__ __device__
+void CheckIsConvertibleButNotConvertibleTo() {
+  // Sanity check T is either implicitly xor explicitly convertible to U.
+  static_assert(cuda::std::is_convertible_v<T, U>);
+  static_assert(cuda::std::is_convertible_v<const T, U>);
+  static_assert(cuda::std::is_convertible_v<T, const U>);
+  static_assert(cuda::std::is_convertible_v<const T, const U>);
+  CheckNotConvertibleTo<T, U>();
+}
+
+// Tests that should objectively return false (except for bool and nullptr_t)
+#if TEST_STD_VER >= 17
+template <class T>
+  #else
+_LIBCUDACXX_TEMPLATE(class T)
+  (requires !(cuda::std::same_as<T, bool> || cuda::std::same_as<T, nullptr_t>))
+#endif
+__host__ __device__
+constexpr void CommonlyNotConvertibleTo() {
+  CheckNotConvertibleTo<T, void>();
+  CheckNotConvertibleTo<T, nullptr_t>();
+  CheckNotConvertibleTo<T, T*>();
+  CheckNotConvertibleTo<T, T Empty::*>();
+  CheckNotConvertibleTo<T, T (Empty::*)()>();
+  CheckNotConvertibleTo<T, T[sizeof(T)]>();
+  CheckNotConvertibleTo<T, T (*)()>();
+  CheckNotConvertibleTo<T, T (&)()>();
+  CheckNotConvertibleTo<T, T(&&)()>();
+}
+
+_LIBCUDACXX_TEMPLATE(class T)
+  (requires cuda::std::same_as<T, bool>)
+__host__ __device__
+constexpr void CommonlyNotConvertibleTo() {
+  CheckNotConvertibleTo<bool, void>();
+  CheckNotConvertibleTo<bool, nullptr_t>();
+  CheckConvertibleTo<bool Empty::*, bool>();
+  CheckConvertibleTo<bool (Empty::*)(), bool>();
+  CheckConvertibleTo<bool[2], bool>();
+  CheckConvertibleTo<bool (*)(), bool>();
+  CheckConvertibleTo<bool (&)(), bool>();
+  CheckConvertibleTo<bool(&&)(), bool>();
+}
+
+_LIBCUDACXX_TEMPLATE(class T)
+  (requires cuda::std::same_as<T, nullptr_t>)
+__host__ __device__
+constexpr void CommonlyNotConvertibleTo() {
+  CheckNotConvertibleTo<nullptr_t, void>();
+  CheckConvertibleTo<nullptr_t, nullptr_t>();
+  CheckConvertibleTo<nullptr_t, void*>();
+  CheckConvertibleTo<nullptr_t, int Empty::*>();
+  CheckConvertibleTo<nullptr_t, void (Empty::*)()>();
+  CheckNotConvertibleTo<nullptr_t, int[2]>();
+  CheckConvertibleTo<nullptr_t, void (*)()>();
+  CheckNotConvertibleTo<nullptr_t, void (&)()>();
+  CheckNotConvertibleTo<nullptr_t, void(&&)()>();
+}
+} // namespace
+
+using Function = void();
+using NoexceptFunction = void() noexcept;
+using ConstFunction = void() const;
+using Array = char[1];
+
+struct StringType {
+  StringType(const char*) {}
+};
+
+class NonCopyable {
+  NonCopyable(NonCopyable&);
+};
+
+template <typename T>
+class CannotInstantiate {
+  enum { X = T::ThisExpressionWillBlowUp };
+};
+
+struct abstract {
+  virtual int f() = 0;
+};
+
+struct ExplicitlyConvertible;
+struct ImplicitlyConvertible;
+
+struct ExplicitlyConstructible {
+  explicit ExplicitlyConstructible(int);
+  explicit ExplicitlyConstructible(ExplicitlyConvertible);
+  explicit ExplicitlyConstructible(ImplicitlyConvertible) = delete;
+};
+
+struct ExplicitlyConvertible {
+  explicit operator ExplicitlyConstructible() const {
+    return ExplicitlyConstructible(0);
+  }
+};
+
+struct ImplicitlyConstructible;
+
+struct ImplicitlyConvertible {
+  operator ExplicitlyConstructible() const;
+  operator ImplicitlyConstructible() const = delete;
+};
+
+struct ImplicitlyConstructible {
+  ImplicitlyConstructible(ImplicitlyConvertible);
+};
+
+int main(int, char**) {
+  // void
+  CheckConvertibleTo<void, void>();
+  CheckNotConvertibleTo<void, Function>();
+  CheckNotConvertibleTo<void, Function&>();
+  CheckNotConvertibleTo<void, Function*>();
+  CheckNotConvertibleTo<void, NoexceptFunction>();
+  CheckNotConvertibleTo<void, NoexceptFunction&>();
+  CheckNotConvertibleTo<void, NoexceptFunction*>();
+  CheckNotConvertibleTo<void, Array>();
+  CheckNotConvertibleTo<void, Array&>();
+  CheckNotConvertibleTo<void, char>();
+  CheckNotConvertibleTo<void, char&>();
+  CheckNotConvertibleTo<void, char*>();
+  CheckNotConvertibleTo<char, void>();
+
+  // Function
+  CheckNotConvertibleTo<Function, void>();
+  CheckNotConvertibleTo<Function, Function>();
+  //CheckNotConvertibleTo<Function, NoexceptFunction>();
+  //CheckNotConvertibleTo<Function, NoexceptFunction&>();
+  //CheckNotConvertibleTo<Function, NoexceptFunction*>();
+  //CheckNotConvertibleTo<Function, NoexceptFunction* const>();
+  CheckConvertibleTo<Function, Function&>();
+  CheckConvertibleTo<Function, Function*>();
+  CheckConvertibleTo<Function, Function* const>();
+
+  static_assert(convertible_to<Function, Function&&>);
+  //static_assert(!convertible_to<Function, NoexceptFunction&&>);
+
+  CheckNotConvertibleTo<Function, Array>();
+  CheckNotConvertibleTo<Function, Array&>();
+  CheckNotConvertibleTo<Function, char>();
+  CheckNotConvertibleTo<Function, char&>();
+  CheckNotConvertibleTo<Function, char*>();
+
+  // Function&
+  CheckNotConvertibleTo<Function&, void>();
+  CheckNotConvertibleTo<Function&, Function>();
+  CheckConvertibleTo<Function&, Function&>();
+
+  CheckConvertibleTo<Function&, Function*>();
+  CheckNotConvertibleTo<Function&, Array>();
+  CheckNotConvertibleTo<Function&, Array&>();
+  CheckNotConvertibleTo<Function&, char>();
+  CheckNotConvertibleTo<Function&, char&>();
+  CheckNotConvertibleTo<Function&, char*>();
+
+  // Function*
+  CheckNotConvertibleTo<Function*, void>();
+  CheckNotConvertibleTo<Function*, Function>();
+  CheckNotConvertibleTo<Function*, Function&>();
+  CheckConvertibleTo<Function*, Function*>();
+
+  CheckNotConvertibleTo<Function*, Array>();
+  CheckNotConvertibleTo<Function*, Array&>();
+  CheckNotConvertibleTo<Function*, char>();
+  CheckNotConvertibleTo<Function*, char&>();
+  CheckNotConvertibleTo<Function*, char*>();
+
+  // Non-referencable function type
+  static_assert(!convertible_to<ConstFunction, Function>);
+  static_assert(!convertible_to<ConstFunction, Function*>);
+  static_assert(!convertible_to<ConstFunction, Function&>);
+  static_assert(!convertible_to<ConstFunction, Function&&>);
+  static_assert(!convertible_to<Function*, ConstFunction>);
+  static_assert(!convertible_to<Function&, ConstFunction>);
+  static_assert(!convertible_to<ConstFunction, ConstFunction>);
+  static_assert(!convertible_to<ConstFunction, void>);
+
+  // NoexceptFunction
+  CheckNotConvertibleTo<NoexceptFunction, void>();
+  CheckNotConvertibleTo<NoexceptFunction, Function>();
+  CheckNotConvertibleTo<NoexceptFunction, NoexceptFunction>();
+  CheckConvertibleTo<NoexceptFunction, NoexceptFunction&>();
+  CheckConvertibleTo<NoexceptFunction, NoexceptFunction*>();
+  CheckConvertibleTo<NoexceptFunction, NoexceptFunction* const>();
+  CheckConvertibleTo<NoexceptFunction, Function&>();
+  CheckConvertibleTo<NoexceptFunction, Function*>();
+  CheckConvertibleTo<NoexceptFunction, Function* const>();
+
+  static_assert(convertible_to<NoexceptFunction, Function&&>);
+  static_assert(convertible_to<NoexceptFunction, NoexceptFunction&&>);
+
+  CheckNotConvertibleTo<NoexceptFunction, Array>();
+  CheckNotConvertibleTo<NoexceptFunction, Array&>();
+  CheckNotConvertibleTo<NoexceptFunction, char>();
+  CheckNotConvertibleTo<NoexceptFunction, char&>();
+  CheckNotConvertibleTo<NoexceptFunction, char*>();
+
+  // NoexceptFunction&
+  CheckNotConvertibleTo<NoexceptFunction&, void>();
+  CheckNotConvertibleTo<NoexceptFunction&, Function>();
+  CheckNotConvertibleTo<NoexceptFunction&, NoexceptFunction>();
+  CheckConvertibleTo<NoexceptFunction&, Function&>();
+  CheckConvertibleTo<NoexceptFunction&, NoexceptFunction&>();
+
+  CheckConvertibleTo<NoexceptFunction&, Function*>();
+  CheckConvertibleTo<NoexceptFunction&, NoexceptFunction*>();
+  CheckNotConvertibleTo<NoexceptFunction&, Array>();
+  CheckNotConvertibleTo<NoexceptFunction&, Array&>();
+  CheckNotConvertibleTo<NoexceptFunction&, char>();
+  CheckNotConvertibleTo<NoexceptFunction&, char&>();
+  CheckNotConvertibleTo<NoexceptFunction&, char*>();
+
+  // NoexceptFunction*
+  CheckNotConvertibleTo<NoexceptFunction*, void>();
+  CheckNotConvertibleTo<NoexceptFunction*, Function>();
+  CheckNotConvertibleTo<NoexceptFunction*, Function&>();
+  CheckNotConvertibleTo<NoexceptFunction*, NoexceptFunction>();
+  CheckNotConvertibleTo<NoexceptFunction*, NoexceptFunction&>();
+  CheckConvertibleTo<NoexceptFunction*, Function*>();
+  CheckConvertibleTo<NoexceptFunction*, NoexceptFunction*>();
+
+  CheckNotConvertibleTo<NoexceptFunction*, Array>();
+  CheckNotConvertibleTo<NoexceptFunction*, Array&>();
+  CheckNotConvertibleTo<NoexceptFunction*, char>();
+  CheckNotConvertibleTo<NoexceptFunction*, char&>();
+  CheckNotConvertibleTo<NoexceptFunction*, char*>();
+
+  // Array
+  CheckNotConvertibleTo<Array, void>();
+  CheckNotConvertibleTo<Array, Function>();
+  CheckNotConvertibleTo<Array, Function&>();
+  CheckNotConvertibleTo<Array, Function*>();
+  CheckNotConvertibleTo<Array, NoexceptFunction>();
+  CheckNotConvertibleTo<Array, NoexceptFunction&>();
+  CheckNotConvertibleTo<Array, NoexceptFunction*>();
+  CheckNotConvertibleTo<Array, Array>();
+
+  static_assert(!convertible_to<Array, Array&>);
+  static_assert(convertible_to<Array, const Array&>);
+  static_assert(!convertible_to<Array, const volatile Array&>);
+
+  static_assert(!convertible_to<const Array, Array&>);
+  static_assert(convertible_to<const Array, const Array&>);
+  static_assert(!convertible_to<Array, volatile Array&>);
+  static_assert(!convertible_to<Array, const volatile Array&>);
+
+  static_assert(convertible_to<Array, Array&&>);
+  static_assert(convertible_to<Array, const Array&&>);
+  static_assert(convertible_to<Array, volatile Array&&>);
+  static_assert(convertible_to<Array, const volatile Array&&>);
+  static_assert(convertible_to<const Array, const Array&&>);
+  static_assert(!convertible_to<Array&, Array&&>);
+  static_assert(!convertible_to<Array&&, Array&>);
+
+  CheckNotConvertibleTo<Array, char>();
+  CheckNotConvertibleTo<Array, char&>();
+
+  static_assert(convertible_to<Array, char*>);
+  static_assert(convertible_to<Array, const char*>);
+  static_assert(convertible_to<Array, char* const>);
+  static_assert(convertible_to<Array, char* const volatile>);
+
+  static_assert(!convertible_to<const Array, char*>);
+  static_assert(convertible_to<const Array, const char*>);
+
+  static_assert(!convertible_to<char[42][42], char*>);
+  static_assert(!convertible_to<char[][1], char*>);
+
+  // Array&
+  CheckNotConvertibleTo<Array&, void>();
+  CheckNotConvertibleTo<Array&, Function>();
+  CheckNotConvertibleTo<Array&, Function&>();
+  CheckNotConvertibleTo<Array&, Function*>();
+  CheckNotConvertibleTo<Array&, NoexceptFunction>();
+  CheckNotConvertibleTo<Array&, NoexceptFunction&>();
+  CheckNotConvertibleTo<Array&, NoexceptFunction*>();
+  CheckNotConvertibleTo<Array&, Array>();
+
+  static_assert(convertible_to<Array&, Array&>);
+  static_assert(convertible_to<Array&, const Array&>);
+  static_assert(!convertible_to<const Array&, Array&>);
+  static_assert(convertible_to<const Array&, const Array&>);
+
+  CheckNotConvertibleTo<Array&, char>();
+  CheckNotConvertibleTo<Array&, char&>();
+
+  static_assert(convertible_to<Array&, char*>);
+  static_assert(convertible_to<Array&, const char*>);
+  static_assert(!convertible_to<const Array&, char*>);
+  static_assert(convertible_to<const Array&, const char*>);
+
+  static_assert(convertible_to<Array, StringType>);
+  static_assert(convertible_to<char(&)[], StringType>);
+
+  // char
+  CheckNotConvertibleTo<char, void>();
+  CheckNotConvertibleTo<char, Function>();
+  CheckNotConvertibleTo<char, Function&>();
+  CheckNotConvertibleTo<char, Function*>();
+  CheckNotConvertibleTo<char, NoexceptFunction>();
+  CheckNotConvertibleTo<char, NoexceptFunction&>();
+  CheckNotConvertibleTo<char, NoexceptFunction*>();
+  CheckNotConvertibleTo<char, Array>();
+  CheckNotConvertibleTo<char, Array&>();
+
+  CheckConvertibleTo<char, char>();
+
+  static_assert(!convertible_to<char, char&>);
+  static_assert(convertible_to<char, const char&>);
+  static_assert(!convertible_to<const char, char&>);
+  static_assert(convertible_to<const char, const char&>);
+
+  CheckNotConvertibleTo<char, char*>();
+
+  // char&
+  CheckNotConvertibleTo<char&, void>();
+  CheckNotConvertibleTo<char&, Function>();
+  CheckNotConvertibleTo<char&, Function&>();
+  CheckNotConvertibleTo<char&, Function*>();
+  CheckNotConvertibleTo<char&, NoexceptFunction>();
+  CheckNotConvertibleTo<char&, NoexceptFunction&>();
+  CheckNotConvertibleTo<char&, NoexceptFunction*>();
+  CheckNotConvertibleTo<char&, Array>();
+  CheckNotConvertibleTo<char&, Array&>();
+
+  CheckConvertibleTo<char&, char>();
+
+  static_assert(convertible_to<char&, char&>);
+  static_assert(convertible_to<char&, const char&>);
+  static_assert(!convertible_to<const char&, char&>);
+  static_assert(convertible_to<const char&, const char&>);
+
+  CheckNotConvertibleTo<char&, char*>();
+
+  // char*
+  CheckNotConvertibleTo<char*, void>();
+  CheckNotConvertibleTo<char*, Function>();
+  CheckNotConvertibleTo<char*, Function&>();
+  CheckNotConvertibleTo<char*, Function*>();
+  CheckNotConvertibleTo<char*, NoexceptFunction>();
+  CheckNotConvertibleTo<char*, NoexceptFunction&>();
+  CheckNotConvertibleTo<char*, NoexceptFunction*>();
+  CheckNotConvertibleTo<char*, Array>();
+  CheckNotConvertibleTo<char*, Array&>();
+
+  CheckNotConvertibleTo<char*, char>();
+  CheckNotConvertibleTo<char*, char&>();
+
+  static_assert(convertible_to<char*, char*>);
+  static_assert(convertible_to<char*, const char*>);
+  static_assert(!convertible_to<const char*, char*>);
+  static_assert(convertible_to<const char*, const char*>);
+
+  // NonCopyable
+  static_assert(convertible_to<NonCopyable&, NonCopyable&>);
+  static_assert(convertible_to<NonCopyable&, const NonCopyable&>);
+  static_assert(convertible_to<NonCopyable&, const volatile NonCopyable&>);
+  static_assert(convertible_to<NonCopyable&, volatile NonCopyable&>);
+  static_assert(convertible_to<const NonCopyable&, const NonCopyable&>);
+  static_assert(
+      convertible_to<const NonCopyable&, const volatile NonCopyable&>);
+  static_assert(
+      convertible_to<volatile NonCopyable&, const volatile NonCopyable&>);
+  static_assert(convertible_to<const volatile NonCopyable&,
+                                    const volatile NonCopyable&>);
+  static_assert(!convertible_to<const NonCopyable&, NonCopyable&>);
+
+  // This test requires Access control SFINAE which we only have in C++11 or when
+  // we are using the compiler builtin for convertible_to.
+  CheckNotConvertibleTo<NonCopyable&, NonCopyable>();
+
+  // Ensure that CannotInstantiate is not instantiated by convertible_to when it is not needed.
+  // For example CannotInstantiate is instantiated as a part of ADL lookup for arguments of type CannotInstantiate*.
+  //static_assert(
+  //    convertible_to<CannotInstantiate<int>*, CannotInstantiate<int>*>);
+
+  // Test for PR13592
+  static_assert(!convertible_to<abstract, abstract>);
+
+  CommonlyNotConvertibleTo<int>();
+  CommonlyNotConvertibleTo<bool>();
+  CommonlyNotConvertibleTo<nullptr_t>();
+
+  CheckNotConvertibleTo<int, ExplicitlyConstructible>();
+  CheckNotConvertibleTo<ExplicitlyConvertible, ExplicitlyConstructible>();
+  CheckNotConvertibleTo<ExplicitlyConstructible, ExplicitlyConvertible>();
+  CheckIsConvertibleButNotConvertibleTo<ImplicitlyConvertible,
+                                        ExplicitlyConstructible>();
+  CheckNotConvertibleTo<ImplicitlyConstructible, ImplicitlyConvertible>();
+
+  return 0;
+}
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.copyconstructible/copy_constructible.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.copyconstructible/copy_constructible.compile.pass.cpp
new file mode 100644
index 0000000000..3ff848e30e
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.copyconstructible/copy_constructible.compile.pass.cpp
@@ -0,0 +1,179 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept copy_constructible;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "type_classification/moveconstructible.h"
+
+using cuda::std::copy_constructible;
+
+// Tests in this namespace are shared with moveconstructible.pass.cpp
+// There are some interesting differences, so it's best if they're tested here
+// too.
+namespace MoveConstructibleTests {
+static_assert(copy_constructible<int>);
+static_assert(copy_constructible<int*>);
+static_assert(copy_constructible<int&>);
+static_assert(copy_constructible<const int>);
+static_assert(copy_constructible<const int&>);
+static_assert(copy_constructible<volatile int>);
+static_assert(copy_constructible<volatile int&>);
+static_assert(copy_constructible<int (*)()>);
+static_assert(copy_constructible<int (&)()>);
+static_assert(copy_constructible<HasDefaultOps>);
+static_assert(copy_constructible<const CustomMoveCtor&>);
+static_assert(copy_constructible<volatile CustomMoveCtor&>);
+static_assert(copy_constructible<const CustomMoveAssign&>);
+static_assert(copy_constructible<volatile CustomMoveAssign&>);
+static_assert(copy_constructible<int HasDefaultOps::*>);
+static_assert(copy_constructible<void (HasDefaultOps::*)(int)>);
+static_assert(copy_constructible<MemberLvalueReference>);
+
+static_assert(!copy_constructible<void>);
+static_assert(!copy_constructible<CustomMoveAssign>);
+static_assert(!copy_constructible<const CustomMoveCtor>);
+static_assert(!copy_constructible<volatile CustomMoveCtor>);
+static_assert(!copy_constructible<const CustomMoveAssign>);
+static_assert(!copy_constructible<volatile CustomMoveAssign>);
+static_assert(!copy_constructible<int[10]>);
+static_assert(!copy_constructible<DeletedMoveCtor>);
+static_assert(!copy_constructible<ImplicitlyDeletedMoveCtor>);
+static_assert(!copy_constructible<DeletedMoveAssign>);
+static_assert(!copy_constructible<ImplicitlyDeletedMoveAssign>);
+
+static_assert(copy_constructible<DeletedMoveCtor&>);
+static_assert(copy_constructible<const DeletedMoveCtor&>);
+static_assert(copy_constructible<ImplicitlyDeletedMoveCtor&>);
+static_assert(copy_constructible<const ImplicitlyDeletedMoveCtor&>);
+static_assert(copy_constructible<DeletedMoveAssign&>);
+static_assert(copy_constructible<const DeletedMoveAssign&>);
+static_assert(copy_constructible<ImplicitlyDeletedMoveAssign&>);
+static_assert(copy_constructible<const ImplicitlyDeletedMoveAssign&>);
+
+// different to moveconstructible.pass.cpp
+static_assert(!copy_constructible<int&&>);
+static_assert(!copy_constructible<const int&&>);
+static_assert(!copy_constructible<volatile int&&>);
+static_assert(!copy_constructible<CustomMoveCtor>);
+static_assert(!copy_constructible<MoveOnly>);
+static_assert(!copy_constructible<const CustomMoveCtor&&>);
+static_assert(!copy_constructible<volatile CustomMoveCtor&&>);
+static_assert(!copy_constructible<const CustomMoveAssign&&>);
+static_assert(!copy_constructible<volatile CustomMoveAssign&&>);
+static_assert(!copy_constructible<DeletedMoveCtor&&>);
+static_assert(!copy_constructible<const DeletedMoveCtor&&>);
+static_assert(!copy_constructible<ImplicitlyDeletedMoveCtor&&>);
+static_assert(!copy_constructible<const ImplicitlyDeletedMoveCtor&&>);
+static_assert(!copy_constructible<DeletedMoveAssign&&>);
+static_assert(!copy_constructible<const DeletedMoveAssign&&>);
+static_assert(!copy_constructible<ImplicitlyDeletedMoveAssign&&>);
+static_assert(!copy_constructible<const ImplicitlyDeletedMoveAssign&&>);
+static_assert(!copy_constructible<MemberRvalueReference>);
+} // namespace MoveConstructibleTests
+
+namespace CopyConstructibleTests {
+struct CopyCtorUserDefined {
+  CopyCtorUserDefined(CopyCtorUserDefined&&) noexcept = default;
+  CopyCtorUserDefined(const CopyCtorUserDefined&);
+};
+static_assert(copy_constructible<CopyCtorUserDefined>);
+
+struct CopyAssignUserDefined {
+  CopyAssignUserDefined& operator=(CopyAssignUserDefined&&) noexcept = default;
+  CopyAssignUserDefined& operator=(const CopyAssignUserDefined&);
+};
+static_assert(!copy_constructible<CopyAssignUserDefined>);
+
+struct CopyCtorAndAssignUserDefined {
+  CopyCtorAndAssignUserDefined(CopyCtorAndAssignUserDefined&&) noexcept =
+      default;
+  CopyCtorAndAssignUserDefined(const CopyCtorAndAssignUserDefined&);
+  CopyCtorAndAssignUserDefined&
+  operator=(CopyCtorAndAssignUserDefined&&) noexcept = default;
+  CopyCtorAndAssignUserDefined& operator=(const CopyCtorAndAssignUserDefined&);
+};
+static_assert(copy_constructible<CopyCtorAndAssignUserDefined>);
+
+struct CopyCtorDeleted {
+  CopyCtorDeleted(CopyCtorDeleted&&) noexcept = default;
+  CopyCtorDeleted(const CopyCtorDeleted&) = delete;
+};
+static_assert(!copy_constructible<CopyCtorDeleted>);
+
+struct CopyAssignDeleted {
+  CopyAssignDeleted(CopyAssignDeleted&&) noexcept = default;
+  CopyAssignDeleted(const CopyAssignDeleted&) = delete;
+};
+static_assert(!copy_constructible<CopyAssignDeleted>);
+
+struct CopyCtorHasMutableRef {
+  CopyCtorHasMutableRef(CopyCtorHasMutableRef&&) noexcept = default;
+  CopyCtorHasMutableRef(CopyCtorHasMutableRef&) = default;
+};
+static_assert(!copy_constructible<CopyCtorHasMutableRef>);
+
+struct CopyCtorProhibitsMutableRef {
+  CopyCtorProhibitsMutableRef(CopyCtorProhibitsMutableRef&&) noexcept = default;
+  CopyCtorProhibitsMutableRef(const CopyCtorProhibitsMutableRef&) = default;
+  CopyCtorProhibitsMutableRef(CopyCtorProhibitsMutableRef&) = delete;
+};
+static_assert(!copy_constructible<CopyCtorProhibitsMutableRef>);
+
+struct CopyAssignHasMutableRef {
+  CopyAssignHasMutableRef&
+  operator=(CopyAssignHasMutableRef&&) noexcept = default;
+  CopyAssignHasMutableRef& operator=(CopyAssignHasMutableRef&) = default;
+};
+static_assert(!copy_constructible<CopyAssignHasMutableRef>);
+
+struct CopyAssignProhibitsMutableRef {
+  CopyAssignProhibitsMutableRef&
+  operator=(CopyAssignProhibitsMutableRef&&) noexcept = default;
+  CopyAssignProhibitsMutableRef&
+  operator=(const CopyAssignProhibitsMutableRef&) = default;
+  CopyAssignProhibitsMutableRef&
+  operator=(CopyAssignProhibitsMutableRef&) = delete;
+};
+static_assert(!copy_constructible<CopyAssignProhibitsMutableRef>);
+
+struct CopyCtorOnly {
+  CopyCtorOnly(CopyCtorOnly&&) noexcept = delete;
+  CopyCtorOnly(const CopyCtorOnly&) = default;
+};
+static_assert(!copy_constructible<CopyCtorOnly>);
+
+struct CopyAssignOnly {
+  CopyAssignOnly& operator=(CopyAssignOnly&&) noexcept = delete;
+  CopyAssignOnly& operator=(const CopyAssignOnly&) = default;
+};
+static_assert(!copy_constructible<CopyAssignOnly>);
+
+struct CopyOnly {
+  CopyOnly(CopyOnly&&) noexcept = delete;
+  CopyOnly(const CopyOnly&) = default;
+
+  CopyOnly& operator=(CopyOnly&&) noexcept = delete;
+  CopyOnly& operator=(const CopyOnly&) = default;
+};
+static_assert(!copy_constructible<CopyOnly>);
+
+struct ExplicitlyCopyable {
+  ExplicitlyCopyable(ExplicitlyCopyable&&) = default;
+  explicit ExplicitlyCopyable(const ExplicitlyCopyable&);
+};
+static_assert(!copy_constructible<ExplicitlyCopyable>);
+} // namespace CopyConstructibleTests
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp
new file mode 100644
index 0000000000..e5b9f30f04
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp
@@ -0,0 +1,196 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// We voluntarily use cuda::std::default_initializable on types that have redundant
+// or ignored cv-qualifiers -- don't warn about it.
+// ADDITIONAL_COMPILE_FLAGS: -Wno-ignored-qualifiers
+
+// template<class T>
+//     concept default_initializable = constructible_from<T> &&
+//     requires { T{}; } &&
+//     is-default-initializable<T>;
+
+#include <cuda/std/array>
+#include <cuda/std/concepts>
+
+#include "test_macros.h"
+
+struct Empty {};
+
+struct CtorDefaulted {
+  CtorDefaulted() = default;
+};
+struct CtorDeleted {
+  CtorDeleted() = delete;
+};
+struct DtorDefaulted {
+  ~DtorDefaulted() = default;
+};
+struct DtorDeleted {
+  ~DtorDeleted() = delete;
+};
+
+struct Noexcept {
+  ~Noexcept() noexcept;
+};
+struct NoexceptTrue {
+  ~NoexceptTrue() noexcept(true);
+};
+struct NoexceptFalse {
+  ~NoexceptFalse() noexcept(false);
+};
+
+struct CtorProtected {
+protected:
+  CtorProtected() = default;
+};
+struct CtorPrivate {
+private:
+  CtorPrivate() = default;
+};
+struct DtorProtected {
+protected:
+  ~DtorProtected() = default;
+};
+struct DtorPrivate {
+private:
+  ~DtorPrivate() = default;
+};
+
+template <class T>
+struct NoexceptDependant {
+  ~NoexceptDependant() noexcept(cuda::std::is_same_v<T, int>);
+};
+
+struct CtorExplicit {
+  explicit CtorExplicit() = default;
+};
+struct CtorArgument {
+  CtorArgument(int) {}
+};
+struct CtorDefaultArgument {
+  CtorDefaultArgument(int = 0) {}
+};
+struct CtorExplicitDefaultArgument {
+  explicit CtorExplicitDefaultArgument(int = 0) {}
+};
+
+struct Derived : public Empty {};
+
+class Abstract {
+  virtual void foo() = 0;
+};
+
+class AbstractDestructor {
+  virtual ~AbstractDestructor() = 0;
+};
+
+class OperatorNewDeleted {
+  void* operator new(std::size_t) = delete;
+  void operator delete(void* ptr) = delete;
+};
+
+template<class T>
+void test_not_const()
+{
+    static_assert( cuda::std::default_initializable<               T>);
+    static_assert(!cuda::std::default_initializable<const          T>);
+    static_assert( cuda::std::default_initializable<      volatile T>);
+    static_assert(!cuda::std::default_initializable<const volatile T>);
+}
+
+template<class T>
+void test_true()
+{
+    static_assert( cuda::std::default_initializable<               T>);
+    static_assert( cuda::std::default_initializable<const          T>);
+    static_assert( cuda::std::default_initializable<      volatile T>);
+    static_assert( cuda::std::default_initializable<const volatile T>);
+}
+
+template<class T>
+void test_false()
+{
+    static_assert(!cuda::std::default_initializable<               T>);
+    static_assert(!cuda::std::default_initializable<const          T>);
+    static_assert(!cuda::std::default_initializable<      volatile T>);
+    static_assert(!cuda::std::default_initializable<const volatile T>);
+}
+
+void test()
+{
+    test_not_const<bool>();
+    test_not_const<char>();
+    test_not_const<int>();
+    test_not_const<double>();
+
+    test_false    <void>();
+    test_not_const<void*>();
+
+    test_not_const<int*>();
+    test_false    <int[]>();
+    test_not_const<int[1]>();
+    test_false    <int&>();
+    test_false    <int&&>();
+
+    test_true     <Empty>();
+
+    test_true     <CtorDefaulted>();
+    test_false    <CtorDeleted>();
+    test_true     <DtorDefaulted>();
+    test_false    <DtorDeleted>();
+
+    test_true     <Noexcept>();
+    test_true     <NoexceptTrue>();
+    test_false    <NoexceptFalse>();
+
+    test_false    <CtorProtected>();
+    test_false    <CtorPrivate>();
+    test_false    <DtorProtected>();
+    test_false    <DtorPrivate>();
+
+    test_true     <NoexceptDependant<int>>();
+    test_false    <NoexceptDependant<double>>();
+
+    test_true     <CtorExplicit>();
+    test_false    <CtorArgument>();
+    test_true     <CtorDefaultArgument>();
+    test_true     <CtorExplicitDefaultArgument>();
+
+    test_true     <Derived>();
+    test_false    <Abstract>();
+    test_false    <AbstractDestructor>();
+
+    test_true     <OperatorNewDeleted>();
+
+    test_not_const<void(*)(const int&)>();
+    test_not_const<void(Empty::*)(const int&)               >();
+    test_not_const<void(Empty::*)(const int&) const         >();
+    test_not_const<void(Empty::*)(const int&)       volatile>();
+    test_not_const<void(Empty::*)(const int&) const volatile>();
+    test_not_const<void(Empty::*)(const int&) &>();
+    test_not_const<void(Empty::*)(const int&) &&>();
+    test_not_const<void(Empty::*)(const int&) noexcept>();
+    test_not_const<void(Empty::*)(const int&) noexcept(true)>();
+    test_not_const<void(Empty::*)(const int&) noexcept(false)>();
+
+    // Sequence containers
+    test_not_const<cuda::std::array<               int, 0>>();
+    test_not_const<cuda::std::array<               int, 1>>();
+    test_false    <cuda::std::array<const          int, 1>>();
+    test_not_const<cuda::std::array<      volatile int, 1>>();
+    test_false    <cuda::std::array<const volatile int, 1>>();
+}
+
+// Required for MSVC internal test runner compatibility.
+int main(int, char**) {
+    return 0;
+}
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp
new file mode 100644
index 0000000000..f14445655e
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.default.init/default_initializable.verify.cpp
@@ -0,0 +1,81 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+//     concept default_initializable = constructible_from<T> &&
+//     requires { T{}; } &&
+//     is-default-initializable<T>;
+
+#include <cuda/std/concepts>
+#include <cuda/std/cassert>
+
+#include "test_macros.h"
+
+template<class T>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  brace_initializable_,
+  requires() //
+  ( T{}));
+  
+template<class T>
+_LIBCUDACXX_CONCEPT brace_initializable = _LIBCUDACXX_FRAGMENT(brace_initializable_, T);
+  
+__host__ __device__
+void test() {
+    // LWG3149
+    // Changed the concept from constructible_from<T>
+    // to constructible_from<T> &&
+    //    requires { T{}; } && is-default-initializable <T>
+    struct S0 { explicit S0() = default; };
+    S0 x0;
+    S0 y0{};
+    static_assert(cuda::std::constructible_from<S0>);
+    static_assert(brace_initializable<S0>);
+    static_assert(cuda::std::__default_initializable<S0>);
+    static_assert(cuda::std::default_initializable<S0>);
+
+    struct S1 { S0 x; }; // Note: aggregate
+    S1 x1;
+    S1 y1{}; // expected-error {{chosen constructor is explicit in copy-initialization}}
+    static_assert(cuda::std::constructible_from<S1>);
+    static_assert(!brace_initializable<S1>);
+    static_assert(cuda::std::__default_initializable<S1>);
+    static_assert(!cuda::std::default_initializable<S1>);
+
+    const int x2; // expected-error {{default initialization of an object of const type 'const int'}}
+    const int y2{};
+
+    static_assert(cuda::std::constructible_from<const int>);
+    static_assert(brace_initializable<const int>);
+    static_assert(!cuda::std::__default_initializable<const int>);
+    static_assert(!cuda::std::default_initializable<const int>);
+
+    const int x3[1]; // expected-error-re {{default initialization of an object of const type 'const int{{[ ]*}}[1]'}}
+    const int y3[1]{};
+    static_assert(cuda::std::constructible_from<const int[1]>);
+    static_assert(brace_initializable<const int[1]>);
+    static_assert(!cuda::std::__default_initializable<const int[1]>);
+    static_assert(!cuda::std::default_initializable<const int[1]>);
+
+    // Zero-length array extension
+    const int x4[]; // expected-error {{definition of variable with array type needs an explicit size or an initializer}}
+    const int y4[]{};
+    static_assert(!cuda::std::constructible_from<const int[]>);
+    static_assert(brace_initializable<const int[]>);
+    static_assert(!cuda::std::__default_initializable<const int[]>);
+    static_assert(!cuda::std::default_initializable<const int[]>);
+}
+
+int main(int, char**) {
+    test();
+
+    return 0;
+}
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.derived/derived_from.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.derived/derived_from.pass.cpp
new file mode 100644
index 0000000000..593554682c
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.derived/derived_from.pass.cpp
@@ -0,0 +1,519 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class Derived, class Base>
+// concept derived_from;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#if TEST_STD_VER > 17
+#define TEST_IF_CONSTEXPR if constexpr
+#else
+#define TEST_IF_CONSTEXPR if
+#endif
+
+using cuda::std::derived_from;
+
+struct Base1 {};
+struct Derived1 : Base1 {};
+struct Derived2 : Base1 {};
+
+struct DerivedPrivate : private Base1 {};
+struct Derived3 : DerivedPrivate {};
+
+struct DerivedProtected : protected DerivedPrivate {};
+struct Derived4 : DerivedProtected {};
+struct Derived5 : Derived4 {};
+
+template <typename From, typename To>
+__host__ __device__
+constexpr void CheckNotDerivedFromPointer() {
+  { // From as pointer
+    static_assert(!derived_from<From*, To>);
+    static_assert(!derived_from<From*, const To>);
+    static_assert(!derived_from<From*, volatile To>);
+    static_assert(!derived_from<From*, const volatile To>);
+
+    TEST_IF_CONSTEXPR (!cuda::std::same_as<To, void>) {
+      static_assert(!derived_from<From*, To&>);
+      static_assert(!derived_from<From*, const To&>);
+      static_assert(!derived_from<From*, volatile To&>);
+      static_assert(!derived_from<From*, const volatile To&>);
+
+      static_assert(!derived_from<From*, To&&>);
+      static_assert(!derived_from<From*, const To&&>);
+      static_assert(!derived_from<From*, volatile To&&>);
+      static_assert(!derived_from<From*, const volatile To&&>);
+
+      static_assert(!derived_from<const From*, To&>);
+      static_assert(!derived_from<const From*, const To&>);
+      static_assert(!derived_from<const From*, volatile To&>);
+      static_assert(!derived_from<const From*, const volatile To&>);
+
+      static_assert(!derived_from<const From*, To&&>);
+      static_assert(!derived_from<const From*, const To&&>);
+      static_assert(!derived_from<const From*, volatile To&&>);
+      static_assert(!derived_from<const From*, const volatile To&&>);
+
+      static_assert(!derived_from<volatile From*, To&>);
+      static_assert(!derived_from<volatile From*, const To&>);
+      static_assert(!derived_from<volatile From*, volatile To&>);
+      static_assert(!derived_from<volatile From*, const volatile To&>);
+
+      static_assert(!derived_from<volatile From*, To&&>);
+      static_assert(!derived_from<volatile From*, const To&&>);
+      static_assert(!derived_from<volatile From*, volatile To&&>);
+      static_assert(!derived_from<volatile From*, const volatile To&&>);
+
+      static_assert(!derived_from<const volatile From*, To&>);
+      static_assert(!derived_from<const volatile From*, const To&>);
+      static_assert(!derived_from<const volatile From*, volatile To&>);
+      static_assert(
+          !derived_from<const volatile From*, const volatile To&>);
+
+      static_assert(!derived_from<const volatile From*, To&&>);
+      static_assert(!derived_from<const volatile From*, const To&&>);
+      static_assert(!derived_from<const volatile From*, volatile To&&>);
+      static_assert(
+          !derived_from<const volatile From*, const volatile To&&>);
+    }
+  }
+  { // To as pointer
+    static_assert(!derived_from<From, To*>);
+    static_assert(!derived_from<From, const To*>);
+    static_assert(!derived_from<From, volatile To*>);
+    static_assert(!derived_from<From, const volatile To*>);
+
+    TEST_IF_CONSTEXPR (!cuda::std::same_as<From, void>) {
+      static_assert(!derived_from<From&, To*>);
+      static_assert(!derived_from<From&, const To*>);
+      static_assert(!derived_from<From&, volatile To*>);
+      static_assert(!derived_from<From&, const volatile To*>);
+
+      static_assert(!derived_from<From&&, To*>);
+      static_assert(!derived_from<From&&, const To*>);
+      static_assert(!derived_from<From&&, volatile To*>);
+      static_assert(!derived_from<From&&, const volatile To*>);
+
+      static_assert(!derived_from<const From&, To*>);
+      static_assert(!derived_from<const From&, const To*>);
+      static_assert(!derived_from<const From&, volatile To*>);
+      static_assert(!derived_from<const From&, const volatile To*>);
+
+      static_assert(!derived_from<const From&&, To*>);
+      static_assert(!derived_from<const From&&, const To*>);
+      static_assert(!derived_from<const From&&, volatile To*>);
+      static_assert(!derived_from<const From&&, const volatile To*>);
+
+      static_assert(!derived_from<volatile From&, To*>);
+      static_assert(!derived_from<volatile From&, const To*>);
+      static_assert(!derived_from<volatile From&, volatile To*>);
+      static_assert(!derived_from<volatile From&, const volatile To*>);
+
+      static_assert(!derived_from<volatile From&&, To*>);
+      static_assert(!derived_from<volatile From&&, const To*>);
+      static_assert(!derived_from<volatile From&&, volatile To*>);
+      static_assert(!derived_from<volatile From&&, const volatile To*>);
+
+      static_assert(!derived_from<const volatile From&, To*>);
+      static_assert(!derived_from<const volatile From&, const To*>);
+      static_assert(!derived_from<const volatile From&, volatile To*>);
+      static_assert(
+          !derived_from<const volatile From&, const volatile To*>);
+
+      static_assert(!derived_from<const volatile From&&, To*>);
+      static_assert(!derived_from<const volatile From&&, const To*>);
+      static_assert(!derived_from<const volatile From&&, volatile To*>);
+      static_assert(
+          !derived_from<const volatile From&&, const volatile To*>);
+    }
+  }
+  { // Both as pointers
+    static_assert(!derived_from<From*, To*>);
+    static_assert(!derived_from<From*, const To*>);
+    static_assert(!derived_from<From*, volatile To*>);
+    static_assert(!derived_from<From*, const volatile To*>);
+
+    static_assert(!derived_from<const From*, To*>);
+    static_assert(!derived_from<const From*, const To*>);
+    static_assert(!derived_from<const From*, volatile To*>);
+    static_assert(!derived_from<const From*, const volatile To*>);
+
+    static_assert(!derived_from<volatile From*, To*>);
+    static_assert(!derived_from<volatile From*, const To*>);
+    static_assert(!derived_from<volatile From*, volatile To*>);
+    static_assert(!derived_from<volatile From*, const volatile To*>);
+
+    static_assert(!derived_from<const volatile From*, To*>);
+    static_assert(!derived_from<const volatile From*, const To*>);
+    static_assert(!derived_from<const volatile From*, volatile To*>);
+    static_assert(!derived_from<const volatile From*, const volatile To*>);
+  }
+
+#if TEST_STD_VER > 17
+  // From as the return type of a pointer-to-function
+  TEST_IF_CONSTEXPR (!cuda::std::is_array_v<From>) {
+    static_assert(!derived_from<From (*)(), To>);
+    static_assert(!derived_from<From (*)(int), To>);
+  }
+
+  // To as the return type of a pointer-to-function
+  TEST_IF_CONSTEXPR (!cuda::std::is_array_v<To>) {
+    static_assert(!derived_from<From, To (*)()>);
+    static_assert(!derived_from<From, To (*)(double)>);
+  }
+
+  // Both as the return type of a pointer-to-function
+  TEST_IF_CONSTEXPR (!cuda::std::is_array_v<From> && !cuda::std::is_array_v<To>) {
+    static_assert(!derived_from<From (*)(), To (*)()>);
+    static_assert(!derived_from<From (*)(int), To (*)(double)>);
+  }
+  { // pointer-to-member
+    TEST_IF_CONSTEXPR (cuda::std::is_class_v<From> && !cuda::std::same_as<To, void>) {
+      static_assert(!derived_from<To From::*, To>);
+    }
+
+    TEST_IF_CONSTEXPR (cuda::std::is_class_v<To> && !cuda::std::same_as<From, void>) {
+      static_assert(!derived_from<From To::*, From>);
+    }
+  }
+  { // pointer-to-member-functions
+    TEST_IF_CONSTEXPR (cuda::std::is_class_v<From>) {
+      static_assert(!derived_from<From (From::*)(), To>);
+    }
+
+    TEST_IF_CONSTEXPR (cuda::std::is_class_v<To>) {
+      static_assert(!derived_from<To (To::*)(), From>);
+    }
+  }
+  #endif
+}
+
+template <typename From, typename To>
+__host__ __device__
+constexpr void CheckNotDerivedFromReference() {
+  TEST_IF_CONSTEXPR (!cuda::std::same_as<To, void>) {
+    static_assert(!derived_from<From, To&>);
+    static_assert(!derived_from<From, const To&>);
+    static_assert(!derived_from<From, volatile To&>);
+    static_assert(!derived_from<From, const volatile To&>);
+
+    static_assert(!derived_from<From, To&&>);
+    static_assert(!derived_from<From, const To&&>);
+    static_assert(!derived_from<From, volatile To&&>);
+    static_assert(!derived_from<From, const volatile To&&>);
+  }
+
+  TEST_IF_CONSTEXPR (!cuda::std::same_as<From, void>) {
+    static_assert(!derived_from<From&, To>);
+    static_assert(!derived_from<From&, To>);
+    static_assert(!derived_from<From&, To>);
+    static_assert(!derived_from<From&, To>);
+
+    static_assert(!derived_from<From&&, To>);
+    static_assert(!derived_from<From&&, To>);
+    static_assert(!derived_from<From&&, To>);
+    static_assert(!derived_from<From&&, To>);
+  }
+
+  // From as lvalue references
+  TEST_IF_CONSTEXPR (!cuda::std::same_as<From, void> && !cuda::std::same_as<To, void>) {
+    static_assert(!derived_from<From&, To&>);
+    static_assert(!derived_from<From&, const To&>);
+    static_assert(!derived_from<From&, volatile To&>);
+    static_assert(!derived_from<From&, const volatile To&>);
+
+    static_assert(!derived_from<From&, To&&>);
+    static_assert(!derived_from<From&, const To&&>);
+    static_assert(!derived_from<From&, volatile To&&>);
+    static_assert(!derived_from<From&, const volatile To&&>);
+
+    static_assert(!derived_from<const From&, To&>);
+    static_assert(!derived_from<const From&, const To&>);
+    static_assert(!derived_from<const From&, volatile To&>);
+    static_assert(!derived_from<const From&, const volatile To&>);
+
+    static_assert(!derived_from<const From&, To&&>);
+    static_assert(!derived_from<const From&, const To&&>);
+    static_assert(!derived_from<const From&, volatile To&&>);
+    static_assert(!derived_from<const From&, const volatile To&&>);
+
+    static_assert(!derived_from<volatile From&, To&>);
+    static_assert(!derived_from<volatile From&, const To&>);
+    static_assert(!derived_from<volatile From&, volatile To&>);
+    static_assert(!derived_from<volatile From&, const volatile To&>);
+
+    static_assert(!derived_from<volatile From&, To&&>);
+    static_assert(!derived_from<volatile From&, const To&&>);
+    static_assert(!derived_from<volatile From&, volatile To&&>);
+    static_assert(!derived_from<volatile From&, const volatile To&&>);
+
+    static_assert(!derived_from<const volatile From&, To&>);
+    static_assert(!derived_from<const volatile From&, const To&>);
+    static_assert(!derived_from<const volatile From&, volatile To&>);
+    static_assert(!derived_from<const volatile From&, const volatile To&>);
+
+    static_assert(!derived_from<const volatile From&, To&&>);
+    static_assert(!derived_from<const volatile From&, const To&&>);
+    static_assert(!derived_from<const volatile From&, volatile To&&>);
+    static_assert(
+        !derived_from<const volatile From&, const volatile To&&>);
+
+    // From as rvalue references
+    static_assert(!derived_from<From&&, To&>);
+    static_assert(!derived_from<From&&, const To&>);
+    static_assert(!derived_from<From&&, volatile To&>);
+    static_assert(!derived_from<From&&, const volatile To&>);
+
+    static_assert(!derived_from<From&&, To&&>);
+    static_assert(!derived_from<From&&, const To&&>);
+    static_assert(!derived_from<From&&, volatile To&&>);
+    static_assert(!derived_from<From&&, const volatile To&&>);
+
+    static_assert(!derived_from<const From&&, To&>);
+    static_assert(!derived_from<const From&&, const To&>);
+    static_assert(!derived_from<const From&&, volatile To&>);
+    static_assert(!derived_from<const From&&, const volatile To&>);
+
+    static_assert(!derived_from<const From&&, To&&>);
+    static_assert(!derived_from<const From&&, const To&&>);
+    static_assert(!derived_from<const From&&, volatile To&&>);
+    static_assert(!derived_from<const From&&, const volatile To&&>);
+
+    static_assert(!derived_from<volatile From&&, To&>);
+    static_assert(!derived_from<volatile From&&, const To&>);
+    static_assert(!derived_from<volatile From&&, volatile To&>);
+    static_assert(!derived_from<volatile From&&, const volatile To&>);
+
+    static_assert(!derived_from<volatile From&&, To&&>);
+    static_assert(!derived_from<volatile From&&, const To&&>);
+    static_assert(!derived_from<volatile From&&, volatile To&&>);
+    static_assert(!derived_from<volatile From&&, const volatile To&&>);
+
+    static_assert(!derived_from<const volatile From&&, To&>);
+    static_assert(!derived_from<const volatile From&&, const To&>);
+    static_assert(!derived_from<const volatile From&&, volatile To&>);
+    static_assert(
+        !derived_from<const volatile From&&, const volatile To&>);
+
+    static_assert(!derived_from<const volatile From&&, To&&>);
+    static_assert(!derived_from<const volatile From&&, const To&&>);
+    static_assert(!derived_from<const volatile From&&, volatile To&&>);
+    static_assert(
+        !derived_from<const volatile From&&, const volatile To&&>);
+  }
+
+#if TEST_STD_VER > 17
+  // From as the return type of a reference-to-function
+  TEST_IF_CONSTEXPR (!cuda::std::is_array_v<From>) {
+    static_assert(!derived_from<From (&)(), To>);
+    static_assert(!derived_from<From (&)(int), To>);
+  }
+  // To as the return type of a reference-to-function
+  TEST_IF_CONSTEXPR (!cuda::std::is_array_v<To>) {
+    static_assert(!derived_from<From, To (&)()>);
+    static_assert(!derived_from<From, To (&)(double)>);
+  }
+  // Both as the return type of a reference-to-function
+  TEST_IF_CONSTEXPR (!cuda::std::is_array_v<From> && !cuda::std::is_array_v<To>) {
+    static_assert(!derived_from<From (&)(), To (&)()>);
+    static_assert(!derived_from<From (&)(int), To (&)(double)>);
+  }
+#endif // TEST_STD_VER > 17
+}
+
+template <typename From, typename To>
+__host__ __device__
+constexpr void CheckDerivedFrom() {
+  static_assert(derived_from<From, To>);
+
+  static_assert(derived_from<From, const To>);
+  static_assert(derived_from<From, volatile To>);
+  static_assert(derived_from<From, const volatile To>);
+
+  static_assert(derived_from<const From, const To>);
+  static_assert(derived_from<const From, volatile To>);
+  static_assert(derived_from<const From, const volatile To>);
+
+  static_assert(derived_from<volatile From, const To>);
+  static_assert(derived_from<volatile From, volatile To>);
+  static_assert(derived_from<volatile From, const volatile To>);
+
+  static_assert(derived_from<const volatile From, const To>);
+  static_assert(derived_from<const volatile From, volatile To>);
+  static_assert(derived_from<const volatile From, const volatile To>);
+
+  CheckNotDerivedFromPointer<From, To>();
+  CheckNotDerivedFromReference<From, To>();
+}
+
+template <typename From, typename To>
+__host__ __device__
+constexpr void CheckNotDerivedFrom() {
+  static_assert(!derived_from<From, To>);
+
+  static_assert(!derived_from<From, const To>);
+  static_assert(!derived_from<From, volatile To>);
+  static_assert(!derived_from<From, const volatile To>);
+
+  static_assert(!derived_from<const From, const To>);
+  static_assert(!derived_from<const From, volatile To>);
+  static_assert(!derived_from<const From, const volatile To>);
+
+  static_assert(!derived_from<volatile From, const To>);
+  static_assert(!derived_from<volatile From, volatile To>);
+  static_assert(!derived_from<volatile From, const volatile To>);
+
+  static_assert(!derived_from<const volatile From, const To>);
+  static_assert(!derived_from<const volatile From, volatile To>);
+  static_assert(!derived_from<const volatile From, const volatile To>);
+
+  CheckNotDerivedFromPointer<From, To>();
+  CheckNotDerivedFromReference<From, To>();
+}
+
+enum Enumeration { Yes, No };
+enum class ScopedEnumeration : int { No, Yes };
+
+int main(int, char**) {
+  { // Fundamentals shouldn't be derived from anything
+    CheckNotDerivedFrom<int, long>();
+    CheckNotDerivedFrom<signed char, char>();
+    CheckNotDerivedFrom<double, Base1>();
+
+    CheckNotDerivedFrom<int, Enumeration>();
+    CheckNotDerivedFrom<int, ScopedEnumeration>();
+
+#if TEST_STD_VER > 17
+    CheckNotDerivedFrom<void, void>();
+#endif 
+    CheckNotDerivedFrom<int, int>();
+  }
+  { // Nothing should be derived from a fundamental type
+    CheckNotDerivedFrom<Enumeration, int>();
+    CheckNotDerivedFrom<ScopedEnumeration, int>();
+
+    CheckNotDerivedFrom<Base1, int>();
+    CheckNotDerivedFrom<Base1, double>();
+    CheckNotDerivedFrom<Derived1, char>();
+    CheckNotDerivedFrom<DerivedPrivate, long long>();
+  }
+  { // Other built-in things shouldn't have derivations
+    CheckNotDerivedFrom<Enumeration, Enumeration>();
+    CheckNotDerivedFrom<ScopedEnumeration, ScopedEnumeration>();
+
+    CheckNotDerivedFrom<Enumeration, ScopedEnumeration>();
+    CheckNotDerivedFrom<ScopedEnumeration, Enumeration>();
+
+    CheckNotDerivedFrom<Base1[5], Base1>();
+    CheckNotDerivedFrom<Derived1[5], Base1>();
+
+    CheckNotDerivedFrom<Base1, Base1[5]>();
+    CheckNotDerivedFrom<Derived1, Base1[5]>();
+  }
+
+  { // Base1 is the subject.
+    CheckDerivedFrom<Base1, Base1>();
+#if TEST_STD_VER > 17
+    CheckNotDerivedFrom<Base1, void>();
+#endif
+    CheckNotDerivedFrom<Base1, DerivedPrivate>();
+    CheckNotDerivedFrom<Base1, DerivedProtected>();
+    CheckNotDerivedFrom<Base1, Derived1>();
+    CheckNotDerivedFrom<Base1, Derived2>();
+    CheckNotDerivedFrom<Base1, Derived3>();
+    CheckNotDerivedFrom<Base1, Derived4>();
+  }
+
+  { // Derived1 is the subject.
+    CheckDerivedFrom<Derived1, Base1>();
+    CheckDerivedFrom<Derived1, Derived1>();
+
+#if TEST_STD_VER > 17
+    CheckNotDerivedFromPointer<Derived1, void>();
+#endif
+    CheckNotDerivedFrom<Derived1, DerivedPrivate>();
+    CheckNotDerivedFrom<Derived1, DerivedProtected>();
+    CheckNotDerivedFrom<Derived1, Derived2>();
+    CheckNotDerivedFrom<Derived1, Derived3>();
+    CheckNotDerivedFrom<Derived1, Derived4>();
+  }
+
+  { // Derived2 is the subject.
+    CheckDerivedFrom<Derived2, Base1>();
+    CheckDerivedFrom<Derived2, Derived2>();
+
+    CheckNotDerivedFrom<Derived2, DerivedPrivate>();
+    CheckNotDerivedFrom<Derived2, DerivedProtected>();
+    CheckNotDerivedFrom<Derived2, Derived1>();
+    CheckNotDerivedFrom<Derived2, Derived3>();
+    CheckNotDerivedFrom<Derived2, Derived4>();
+  }
+
+  { // DerivedPrivate is the subject.
+    CheckDerivedFrom<DerivedPrivate, DerivedPrivate>();
+
+    CheckNotDerivedFrom<DerivedPrivate, Base1>();
+    CheckNotDerivedFrom<DerivedPrivate, DerivedProtected>();
+    CheckNotDerivedFrom<DerivedPrivate, Derived1>();
+    CheckNotDerivedFrom<DerivedPrivate, Derived2>();
+    CheckNotDerivedFrom<DerivedPrivate, Derived3>();
+    CheckNotDerivedFrom<DerivedPrivate, Derived4>();
+  }
+
+  { // Derived3 is the subject.
+    CheckDerivedFrom<Derived3, DerivedPrivate>();
+    CheckDerivedFrom<Derived3, Derived3>();
+
+    CheckNotDerivedFrom<Derived3, Base1>();
+    CheckNotDerivedFrom<Derived3, DerivedProtected>();
+    CheckNotDerivedFrom<Derived3, Derived1>();
+    CheckNotDerivedFrom<Derived3, Derived2>();
+    CheckNotDerivedFrom<Derived3, Derived4>();
+  }
+
+  { // DerivedProtected is the subject.
+    CheckDerivedFrom<DerivedProtected, DerivedProtected>();
+
+    CheckNotDerivedFromPointer<DerivedProtected, Base1>();
+    CheckNotDerivedFromPointer<DerivedProtected, DerivedPrivate>();
+    CheckNotDerivedFromPointer<DerivedProtected, Derived1>();
+    CheckNotDerivedFromPointer<DerivedProtected, Derived2>();
+    CheckNotDerivedFromPointer<DerivedProtected, Derived3>();
+    CheckNotDerivedFromPointer<DerivedProtected, Derived4>();
+  }
+
+  { // Derived4 is the subject.
+    CheckDerivedFrom<Derived4, DerivedProtected>();
+    CheckDerivedFrom<Derived4, Derived4>();
+
+    CheckNotDerivedFrom<Derived4, Base1>();
+    CheckNotDerivedFrom<Derived4, DerivedPrivate>();
+    CheckNotDerivedFrom<Derived4, Derived1>();
+    CheckNotDerivedFrom<Derived4, Derived2>();
+    CheckNotDerivedFrom<Derived4, Derived3>();
+  }
+
+  { // Derived5 is the subject.
+    CheckDerivedFrom<Derived5, DerivedProtected>();
+    CheckDerivedFrom<Derived5, Derived4>();
+    CheckDerivedFrom<Derived5, Derived5>();
+
+    CheckNotDerivedFrom<Derived5, Base1>();
+    CheckNotDerivedFrom<Derived5, DerivedPrivate>();
+    CheckNotDerivedFrom<Derived5, Derived1>();
+    CheckNotDerivedFrom<Derived5, Derived2>();
+    CheckNotDerivedFrom<Derived5, Derived3>();
+  }
+
+  return 0;
+}
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.destructible/destructible.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.destructible/destructible.compile.pass.cpp
new file mode 100644
index 0000000000..e4f7bf6be6
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.destructible/destructible.compile.pass.cpp
@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept destructible = is_nothrow_destructible_v<T>;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+struct Empty {};
+
+struct Defaulted {
+  ~Defaulted() = default;
+};
+struct Deleted {
+  ~Deleted() = delete;
+};
+
+struct Noexcept {
+  ~Noexcept() noexcept;
+};
+struct NoexceptTrue {
+  ~NoexceptTrue() noexcept(true);
+};
+struct NoexceptFalse {
+  ~NoexceptFalse() noexcept(false);
+};
+
+struct Protected {
+protected:
+  ~Protected() = default;
+};
+struct Private {
+private:
+  ~Private() = default;
+};
+
+template <class T>
+struct NoexceptDependant {
+  ~NoexceptDependant() noexcept(cuda::std::is_same_v<T, int>);
+};
+
+template <class T>
+__host__ __device__
+void test() {
+  static_assert(cuda::std::destructible<T> == cuda::std::is_nothrow_destructible_v<T>);
+}
+
+void test() {
+  test<Empty>();
+
+  test<Defaulted>();
+  test<Deleted>();
+
+  test<Noexcept>();
+  test<NoexceptTrue>();
+  test<NoexceptFalse>();
+
+  test<Protected>();
+  test<Private>();
+
+  test<NoexceptDependant<int> >();
+  test<NoexceptDependant<double> >();
+
+  test<bool>();
+  test<char>();
+  test<int>();
+  test<double>();
+}
+
+// Required for MSVC internal test runner compatibility.
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.moveconstructible/move_constructible.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.moveconstructible/move_constructible.compile.pass.cpp
new file mode 100644
index 0000000000..b1a7013d2a
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.moveconstructible/move_constructible.compile.pass.cpp
@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept move_constructible;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "type_classification/moveconstructible.h"
+
+using cuda::std::move_constructible;
+
+static_assert(move_constructible<int>);
+static_assert(move_constructible<int*>);
+static_assert(move_constructible<int&>);
+static_assert(move_constructible<int&&>);
+static_assert(move_constructible<const int>);
+static_assert(move_constructible<const int&>);
+static_assert(move_constructible<const int&&>);
+static_assert(move_constructible<volatile int>);
+static_assert(move_constructible<volatile int&>);
+static_assert(move_constructible<volatile int&&>);
+static_assert(move_constructible<int (*)()>);
+static_assert(move_constructible<int (&)()>);
+static_assert(move_constructible<HasDefaultOps>);
+static_assert(move_constructible<CustomMoveCtor>);
+static_assert(move_constructible<MoveOnly>);
+static_assert(move_constructible<const CustomMoveCtor&>);
+static_assert(move_constructible<volatile CustomMoveCtor&>);
+static_assert(move_constructible<const CustomMoveCtor&&>);
+static_assert(move_constructible<volatile CustomMoveCtor&&>);
+static_assert(move_constructible<CustomMoveAssign>);
+static_assert(move_constructible<const CustomMoveAssign&>);
+static_assert(move_constructible<volatile CustomMoveAssign&>);
+static_assert(move_constructible<const CustomMoveAssign&&>);
+static_assert(move_constructible<volatile CustomMoveAssign&&>);
+static_assert(move_constructible<int HasDefaultOps::*>);
+static_assert(move_constructible<void (HasDefaultOps::*)(int)>);
+static_assert(move_constructible<MemberLvalueReference>);
+static_assert(move_constructible<MemberRvalueReference>);
+
+static_assert(!move_constructible<void>);
+static_assert(!move_constructible<const CustomMoveCtor>);
+static_assert(!move_constructible<volatile CustomMoveCtor>);
+static_assert(!move_constructible<const CustomMoveAssign>);
+static_assert(!move_constructible<volatile CustomMoveAssign>);
+static_assert(!move_constructible<int[10]>);
+static_assert(!move_constructible<DeletedMoveCtor>);
+static_assert(!move_constructible<ImplicitlyDeletedMoveCtor>);
+static_assert(!move_constructible<DeletedMoveAssign>);
+static_assert(!move_constructible<ImplicitlyDeletedMoveAssign>);
+
+static_assert(move_constructible<DeletedMoveCtor&>);
+static_assert(move_constructible<DeletedMoveCtor&&>);
+static_assert(move_constructible<const DeletedMoveCtor&>);
+static_assert(move_constructible<const DeletedMoveCtor&&>);
+static_assert(move_constructible<ImplicitlyDeletedMoveCtor&>);
+static_assert(move_constructible<ImplicitlyDeletedMoveCtor&&>);
+static_assert(move_constructible<const ImplicitlyDeletedMoveCtor&>);
+static_assert(move_constructible<const ImplicitlyDeletedMoveCtor&&>);
+static_assert(move_constructible<DeletedMoveAssign&>);
+static_assert(move_constructible<DeletedMoveAssign&&>);
+static_assert(move_constructible<const DeletedMoveAssign&>);
+static_assert(move_constructible<const DeletedMoveAssign&&>);
+static_assert(move_constructible<ImplicitlyDeletedMoveAssign&>);
+static_assert(move_constructible<ImplicitlyDeletedMoveAssign&&>);
+static_assert(move_constructible<const ImplicitlyDeletedMoveAssign&>);
+static_assert(move_constructible<const ImplicitlyDeletedMoveAssign&&>);
+
+static_assert(!move_constructible<NonMovable>);
+static_assert(!move_constructible<DerivedFromNonMovable>);
+static_assert(!move_constructible<HasANonMovable>);
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.same/same_as.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.same/same_as.pass.cpp
new file mode 100644
index 0000000000..f1ea2ea5a5
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.same/same_as.pass.cpp
@@ -0,0 +1,305 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T, class U>
+// concept same_as;
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+using cuda::std::same_as;
+
+struct S1 {};
+struct S2 {
+  int i;
+
+  int& f();
+  double g(int x) const;
+};
+struct S3 {
+  int& r;
+};
+struct S4 {
+  int&& r;
+};
+struct S5 {
+  int* p;
+};
+
+class C1 {};
+class C2 {
+  /* [[maybe_unused]] */ int i;
+};
+
+class C3 {
+public:
+  int i;
+};
+
+template <class T1, class T2 = T1>
+class C4 {
+  int t1;
+  int t2;
+};
+
+template <class T1, class T2 = T1>
+class C5 {
+  /* [[maybe_unused]] */  T1 t1;
+
+public:
+  T2 t2;
+};
+
+template <class T1, class T2 = T1>
+class C6 {
+public:
+  /* [[maybe_unused]] */  T1 t1;
+  /* [[maybe_unused]] */  T2 t2;
+};
+
+template <class T>
+struct identity {
+  using type = T;
+};
+
+template <template <typename> class Modifier = identity>
+__host__ __device__
+void CheckSameAs() {
+  static_assert(
+      same_as<typename Modifier<int>::type, typename Modifier<int>::type>);
+  static_assert(
+      same_as<typename Modifier<S1>::type, typename Modifier<S1>::type>);
+  static_assert(
+      same_as<typename Modifier<S2>::type, typename Modifier<S2>::type>);
+  static_assert(
+      same_as<typename Modifier<S3>::type, typename Modifier<S3>::type>);
+  static_assert(
+      same_as<typename Modifier<S4>::type, typename Modifier<S4>::type>);
+  static_assert(
+      same_as<typename Modifier<S5>::type, typename Modifier<S5>::type>);
+  static_assert(
+      same_as<typename Modifier<C1>::type, typename Modifier<C1>::type>);
+  static_assert(
+      same_as<typename Modifier<C2>::type, typename Modifier<C2>::type>);
+  static_assert(
+      same_as<typename Modifier<C3>::type, typename Modifier<C3>::type>);
+  static_assert(same_as<typename Modifier<C4<int> >::type,
+                             typename Modifier<C4<int> >::type>);
+  static_assert(same_as<typename Modifier<C4<int&> >::type,
+                             typename Modifier<C4<int&> >::type>);
+  static_assert(same_as<typename Modifier<C4<int&&> >::type,
+                             typename Modifier<C4<int&&> >::type>);
+  static_assert(same_as<typename Modifier<C5<int> >::type,
+                             typename Modifier<C5<int> >::type>);
+  static_assert(same_as<typename Modifier<C5<int&> >::type,
+                             typename Modifier<C5<int&> >::type>);
+  static_assert(same_as<typename Modifier<C5<int&&> >::type,
+                             typename Modifier<C5<int&&> >::type>);
+  static_assert(same_as<typename Modifier<C6<int> >::type,
+                             typename Modifier<C6<int> >::type>);
+  static_assert(same_as<typename Modifier<C6<int&> >::type,
+                             typename Modifier<C6<int&> >::type>);
+  static_assert(same_as<typename Modifier<C6<int&&> >::type,
+                             typename Modifier<C6<int&&> >::type>);
+
+  static_assert(same_as<typename Modifier<void>::type,
+                             typename Modifier<void>::type>);
+}
+
+template <template <typename> class Modifier1,
+          template <typename> class Modifier2>
+__host__ __device__
+void CheckNotSameAs() {
+  static_assert(!same_as<typename Modifier1<int>::type,
+                              typename Modifier2<int>::type>);
+  static_assert(!same_as<typename Modifier1<S1>::type,
+                              typename Modifier2<S1>::type>);
+  static_assert(!same_as<typename Modifier1<S2>::type,
+                              typename Modifier2<S2>::type>);
+  static_assert(!same_as<typename Modifier1<S3>::type,
+                              typename Modifier2<S3>::type>);
+  static_assert(!same_as<typename Modifier1<S4>::type,
+                              typename Modifier2<S4>::type>);
+  static_assert(!same_as<typename Modifier1<S5>::type,
+                              typename Modifier2<S5>::type>);
+  static_assert(!same_as<typename Modifier1<C1>::type,
+                              typename Modifier2<C1>::type>);
+  static_assert(!same_as<typename Modifier1<C2>::type,
+                              typename Modifier2<C2>::type>);
+  static_assert(!same_as<typename Modifier1<C3>::type,
+                              typename Modifier2<C3>::type>);
+  static_assert(!same_as<typename Modifier1<C4<int> >::type,
+                              typename Modifier2<C4<int> >::type>);
+  static_assert(!same_as<typename Modifier1<C4<int&> >::type,
+                              typename Modifier2<C4<int&> >::type>);
+  static_assert(!same_as<typename Modifier1<C4<int&&> >::type,
+                              typename Modifier2<C4<int&&> >::type>);
+  static_assert(!same_as<typename Modifier1<C5<int> >::type,
+                              typename Modifier2<C5<int> >::type>);
+  static_assert(!same_as<typename Modifier1<C5<int&> >::type,
+                              typename Modifier2<C5<int&> >::type>);
+  static_assert(!same_as<typename Modifier1<C5<int&&> >::type,
+                              typename Modifier2<C5<int&&> >::type>);
+  static_assert(!same_as<typename Modifier1<C6<int> >::type,
+                              typename Modifier2<C6<int> >::type>);
+  static_assert(!same_as<typename Modifier1<C6<int&> >::type,
+                              typename Modifier2<C6<int&> >::type>);
+  static_assert(!same_as<typename Modifier1<C6<int&&> >::type,
+                              typename Modifier2<C6<int&&> >::type>);
+}
+
+#if TEST_STD_VER > 17
+// Checks subsumption works as intended
+_LIBCUDACXX_TEMPLATE(class T, class U)
+  (requires same_as<T, U>)
+__host__ __device__
+void SubsumptionTest();
+
+// clang-format off
+_LIBCUDACXX_TEMPLATE(class T, class U)
+  (requires same_as<T, U> && true)
+__host__ __device__
+int SubsumptionTest();
+// clang-format on
+
+static_assert(same_as<int, decltype(SubsumptionTest<int, int>())>);
+static_assert(same_as<int, decltype(SubsumptionTest<void, void>())>);
+static_assert(
+    same_as<int, decltype(SubsumptionTest<int (*)(), int (*)()>())>);
+static_assert(
+    same_as<
+        int, decltype(SubsumptionTest<double (&)(int), double (&)(int)>())>);
+static_assert(
+    same_as<int, decltype(SubsumptionTest<int S2::*, int S2::*>())>);
+static_assert(
+    same_as<int,
+                 decltype(SubsumptionTest<int& (S2::*)(), int& (S2::*)()>())>);
+#endif
+
+int main(int, char**) {
+  { // Checks same_as<T, T> is true
+    CheckSameAs();
+
+    // Checks same_as<T&, T&> is true
+    CheckSameAs<cuda::std::add_lvalue_reference>();
+
+    // Checks same_as<T&&, T&&> is true
+    CheckSameAs<cuda::std::add_rvalue_reference>();
+
+    // Checks same_as<const T, const T> is true
+    CheckSameAs<cuda::std::add_const>();
+
+    // Checks same_as<volatile T, volatile T> is true
+    CheckSameAs<cuda::std::add_volatile>();
+
+    // Checks same_as<const volatile T, const volatile T> is true
+    CheckSameAs<cuda::std::add_cv>();
+
+    // Checks same_as<T*, T*> is true
+    CheckSameAs<cuda::std::add_pointer>();
+
+    // Checks concrete types are identical
+    static_assert(same_as<void, void>);
+
+    using Void = void;
+    static_assert(same_as<void, Void>);
+
+    static_assert(same_as<int[1], int[1]>);
+    static_assert(same_as<int[2], int[2]>);
+
+    static_assert(same_as<int (*)(), int (*)()>);
+    static_assert(same_as<void (&)(), void (&)()>);
+    static_assert(same_as<S1& (*)(S1), S1& (*)(S1)>);
+    static_assert(same_as<C1& (&)(S1, int), C1& (&)(S1, int)>);
+
+    static_assert(same_as<int S2::*, int S2::*>);
+    static_assert(same_as<double S2::*, double S2::*>);
+
+    static_assert(same_as<int& (S2::*)(), int& (S2::*)()>);
+    static_assert(same_as<double& (S2::*)(int), double& (S2::*)(int)>);
+  }
+
+  { // Checks that `T` and `T&` are distinct types
+    CheckNotSameAs<identity, cuda::std::add_lvalue_reference>();
+    CheckNotSameAs<cuda::std::add_lvalue_reference, identity>();
+
+    // Checks that `T` and `T&&` are distinct types
+    CheckNotSameAs<identity, cuda::std::add_rvalue_reference>();
+    CheckNotSameAs<cuda::std::add_rvalue_reference, identity>();
+
+    // Checks that `T` and `const T` are distinct types
+    CheckNotSameAs<identity, cuda::std::add_const>();
+    CheckNotSameAs<cuda::std::add_const, identity>();
+
+    // Checks that `T` and `volatile T` are distinct types
+    CheckNotSameAs<identity, cuda::std::add_volatile>();
+    CheckNotSameAs<cuda::std::add_volatile, identity>();
+
+    // Checks that `T` and `const volatile T` are distinct types
+    CheckNotSameAs<identity, cuda::std::add_cv>();
+    CheckNotSameAs<cuda::std::add_cv, identity>();
+
+    // Checks that `const T` and `volatile T` are distinct types
+    CheckNotSameAs<cuda::std::add_const, cuda::std::add_volatile>();
+    CheckNotSameAs<cuda::std::add_volatile, cuda::std::add_const>();
+
+    // Checks that `const T` and `const volatile T` are distinct types
+    CheckNotSameAs<cuda::std::add_const, cuda::std::add_cv>();
+    CheckNotSameAs<cuda::std::add_cv, cuda::std::add_const>();
+
+    // Checks that `volatile T` and `const volatile T` are distinct types
+    CheckNotSameAs<cuda::std::add_volatile, cuda::std::add_cv>();
+    CheckNotSameAs<cuda::std::add_cv, cuda::std::add_volatile>();
+
+    // Checks `T&` and `T&&` are distinct types
+    CheckNotSameAs<cuda::std::add_lvalue_reference, cuda::std::add_rvalue_reference>();
+    CheckNotSameAs<cuda::std::add_rvalue_reference, cuda::std::add_lvalue_reference>();
+  }
+
+  { // Checks different type names are distinct types
+    static_assert(!same_as<S1, C1>);
+    static_assert(!same_as<C4<int>, C5<int> >);
+    static_assert(!same_as<C4<int>, C5<int> >);
+    static_assert(!same_as<C5<int, double>, C5<double, int> >);
+
+    static_assert(!same_as<int&, const int&>);
+    static_assert(!same_as<int&, volatile int&>);
+    static_assert(!same_as<int&, const volatile int&>);
+
+    static_assert(!same_as<int&&, const int&>);
+    static_assert(!same_as<int&&, volatile int&>);
+    static_assert(!same_as<int&&, const volatile int&>);
+
+    static_assert(!same_as<int&, const int&&>);
+    static_assert(!same_as<int&, volatile int&&>);
+    static_assert(!same_as<int&, const volatile int&&>);
+
+    static_assert(!same_as<int&&, const int&&>);
+    static_assert(!same_as<int&&, volatile int&&>);
+    static_assert(!same_as<int&&, const volatile int&&>);
+
+    static_assert(!same_as<void, int>);
+
+    static_assert(!same_as<int[1], int[2]>);
+    static_assert(!same_as<double[1], int[2]>);
+
+    static_assert(!same_as<int* (*)(), const int* (*)()>);
+    static_assert(!same_as<void (&)(), void (&)(S1)>);
+    static_assert(!same_as<S1 (*)(S1), S1& (*)(S1)>);
+    static_assert(!same_as<C3 (&)(int), C1& (&)(S1, int)>);
+
+    static_assert(!same_as<int S2::*, double S2::*>);
+
+    static_assert(!same_as<int& (S2::*)(), double& (S2::*)(int)>);
+  }
+
+  return 0;
+}
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp
new file mode 100644
index 0000000000..aca1b7dd7a
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp
@@ -0,0 +1,263 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept swappable = // see below
+
+#include <cuda/std/cassert>
+#include <cuda/std/concepts>
+
+#include "test_macros.h"
+#include "type_classification/moveconstructible.h"
+#include "type_classification/swappable.h"
+
+using cuda::std::swappable;
+
+template <class T>
+struct expected {
+  T x;
+  T y;
+};
+
+// clang-format off
+// Checks [concept.swappable]/2.1
+_LIBCUDACXX_TEMPLATE(class T, class U)
+  (requires cuda::std::same_as<cuda::std::remove_cvref_t<T>, cuda::std::remove_cvref_t<U> > &&
+         swappable<cuda::std::remove_cvref_t<T> >) //
+__host__ __device__
+constexpr bool check_swap_21(T&& x, U&& y) {
+  expected<cuda::std::remove_cvref_t<T> > const e{y, x};
+  cuda::std::ranges::swap(cuda::std::forward<T>(x), cuda::std::forward<U>(y));
+  return x == e.x && y == e.y;
+}
+
+// Checks [concept.swappable]/2.2
+_LIBCUDACXX_TEMPLATE(class T, std::size_t N)
+  (requires swappable<T>)
+__host__ __device__
+constexpr bool check_swap_22(T (&x)[N], T (&y)[N]) {
+  expected<T[N]> e;
+  for (std::size_t i = 0; i < N; ++i) {
+    e.x[i] = y[i];
+    e.y[i] = x[i];
+  }
+
+  cuda::std::ranges::swap(x, y);
+  for (std::size_t i = 0; i < N; ++i) {
+    if (x[i] == e.x[i] && y[i] == e.y[i]) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+// Checks [concept.swappable]/2.3
+_LIBCUDACXX_TEMPLATE(class T)
+  (requires swappable<T> && cuda::std::copy_constructible<cuda::std::remove_cvref_t<T> >)
+__host__ __device__
+constexpr bool check_swap_23(T x, T y) {
+  expected<cuda::std::remove_cvref_t<T> > const e{y, x};
+  cuda::std::ranges::swap(x, y);
+  return x == e.x && y == e.y;
+}
+// clang-format on
+
+#if TEST_STD_VER > 17
+__host__ __device__
+constexpr bool check_lvalue_adl_swappable() {
+  auto x = lvalue_adl_swappable(0);
+  auto y = lvalue_adl_swappable(1);
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(x, y));
+  assert(check_swap_21(x, y));
+  return true;
+}
+static_assert(check_lvalue_adl_swappable());
+
+__host__ __device__
+constexpr bool check_rvalue_adl_swappable() {
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(rvalue_adl_swappable(0), rvalue_adl_swappable(1)));
+  assert(check_swap_21(rvalue_adl_swappable(0), rvalue_adl_swappable(1)));
+  return true;
+}
+static_assert(check_rvalue_adl_swappable());
+
+__host__ __device__
+constexpr bool check_lvalue_rvalue_adl_swappable() {
+  auto x = lvalue_rvalue_adl_swappable(0);
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(x, lvalue_rvalue_adl_swappable(1)));
+  assert(check_swap_21(x, lvalue_rvalue_adl_swappable(1)));
+  return true;
+}
+static_assert(check_lvalue_rvalue_adl_swappable());
+
+__host__ __device__
+constexpr bool check_rvalue_lvalue_adl_swappable() {
+  auto x = rvalue_lvalue_adl_swappable(0);
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(rvalue_lvalue_adl_swappable(1), x));
+  assert(check_swap_21(rvalue_lvalue_adl_swappable(1), x));
+  return true;
+}
+static_assert(check_rvalue_lvalue_adl_swappable());
+
+__host__ __device__
+constexpr bool check_throwable_swappable() {
+  auto x = throwable_adl_swappable{0};
+  auto y = throwable_adl_swappable{1};
+  ASSERT_NOT_NOEXCEPT(cuda::std::ranges::swap(x, y));
+  assert(check_swap_21(x, y));
+  return true;
+}
+static_assert(check_throwable_swappable());
+
+__host__ __device__
+constexpr bool check_non_move_constructible_adl_swappable() {
+  auto x = non_move_constructible_adl_swappable{0};
+  auto y = non_move_constructible_adl_swappable{1};
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(x, y));
+  assert(check_swap_21(x, y));
+  return true;
+}
+static_assert(check_non_move_constructible_adl_swappable());
+
+__host__ __device__
+constexpr bool check_non_move_assignable_adl_swappable() {
+  auto x = non_move_assignable_adl_swappable{0};
+  auto y = non_move_assignable_adl_swappable{1};
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(x, y));
+  assert(check_swap_21(x, y));
+  return true;
+}
+static_assert(check_non_move_assignable_adl_swappable());
+#endif // TEST_STD_VER > 17
+
+namespace swappable_namespace {
+enum unscoped { hello, world };
+__host__ __device__
+void swap(unscoped&, unscoped&);
+
+enum class scoped { hello, world };
+__host__ __device__
+void swap(scoped&, scoped&);
+} // namespace swappable_namespace
+
+static_assert(swappable<swappable_namespace::unscoped>);
+static_assert(swappable<swappable_namespace::scoped>);
+
+#if TEST_STD_VER > 17
+__host__ __device__
+constexpr bool check_swap_arrays() {
+  int x[] = {0, 1, 2, 3, 4};
+  int y[] = {5, 6, 7, 8, 9};
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(x, y));
+  assert(check_swap_22(x, y));
+  return true;
+}
+static_assert(check_swap_arrays());
+
+__host__ __device__
+constexpr bool check_lvalue_adl_swappable_arrays() {
+  lvalue_adl_swappable x[] = {{0}, {1}, {2}, {3}};
+  lvalue_adl_swappable y[] = {{4}, {5}, {6}, {7}};
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(x, y));
+  assert(check_swap_22(x, y));
+  return true;
+}
+static_assert(check_lvalue_adl_swappable_arrays());
+
+__host__ __device__
+constexpr bool check_throwable_adl_swappable_arrays() {
+  throwable_adl_swappable x[] = {{0}, {1}, {2}, {3}};
+  throwable_adl_swappable y[] = {{4}, {5}, {6}, {7}};
+  ASSERT_NOT_NOEXCEPT(cuda::std::ranges::swap(x, y));
+  assert(check_swap_22(x, y));
+  return true;
+}
+static_assert(check_throwable_adl_swappable_arrays());
+
+auto global_x = 0;
+ASSERT_NOEXCEPT(cuda::std::ranges::swap(global_x, global_x));
+static_assert(check_swap_23(0, 0));
+static_assert(check_swap_23(0, 1));
+static_assert(check_swap_23(1, 0));
+
+__host__ __device__
+constexpr bool check_swappable_references() {
+  int x = 42;
+  int y = 64;
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(x, y));
+  assert(check_swap_23(x, y));
+  return true;
+}
+static_assert(check_swappable_references());
+
+__host__ __device__
+constexpr bool check_swappable_pointers() {
+  char const* x = "hello";
+  ASSERT_NOEXCEPT(cuda::std::ranges::swap(x, x));
+  assert(check_swap_23(x, {}));
+  return true;
+}
+static_assert(check_swappable_pointers());
+#endif // TEST_STD_VER > 17
+
+namespace union_swap {
+union adl_swappable {
+  int x;
+  double y;
+};
+
+__host__ __device__
+void swap(adl_swappable&, adl_swappable&);
+__host__ __device__
+void swap(adl_swappable&&, adl_swappable&&);
+} // namespace union_swap
+static_assert(swappable<union_swap::adl_swappable>);
+static_assert(swappable<union_swap::adl_swappable&>);
+static_assert(swappable<union_swap::adl_swappable&&>);
+
+// All tests for swappable<T> are implicitly confirmed by `check_swap`, so we only need to
+// sanity check for a few positive cases.
+static_assert(swappable<int volatile&>);
+static_assert(swappable<int&&>);
+static_assert(swappable<int (*)()>);
+static_assert(swappable<int rvalue_adl_swappable::*>);
+static_assert(swappable<int (rvalue_adl_swappable::*)()>);
+
+static_assert(!swappable<void>);
+static_assert(!swappable<int const>);
+static_assert(!swappable<int const&>);
+static_assert(!swappable<int const&&>);
+static_assert(!swappable<int const volatile>);
+static_assert(!swappable<int const volatile&>);
+static_assert(!swappable<int const volatile&&>);
+static_assert(!swappable<int (&)()>);
+static_assert(!swappable<DeletedMoveCtor>);
+static_assert(!swappable<ImplicitlyDeletedMoveCtor>);
+static_assert(!swappable<DeletedMoveAssign>);
+static_assert(!swappable<ImplicitlyDeletedMoveAssign>);
+static_assert(!swappable<NonMovable>);
+static_assert(!swappable<DerivedFromNonMovable>);
+static_assert(!swappable<HasANonMovable>);
+
+using swap_type = std::remove_const_t<decltype(cuda::std::ranges::swap)>;
+static_assert(cuda::std::default_initializable<swap_type>);
+static_assert(cuda::std::move_constructible<swap_type>);
+static_assert(cuda::std::copy_constructible<swap_type>);
+static_assert(cuda::std::assignable_from<swap_type&, swap_type>);
+static_assert(cuda::std::assignable_from<swap_type&, swap_type&>);
+static_assert(cuda::std::assignable_from<swap_type&, swap_type const&>);
+static_assert(cuda::std::assignable_from<swap_type&, swap_type const>);
+static_assert(swappable<swap_type>);
+
+int main(int, char**) {
+  return 0;
+}
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable_with.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable_with.compile.pass.cpp
new file mode 100644
index 0000000000..c1aa6bb975
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concept.swappable/swappable_with.compile.pass.cpp
@@ -0,0 +1,797 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T, class U>
+// concept swappable_with = // see below
+
+#include <cuda/std/concepts>
+#include <cuda/std/cassert>
+
+#include "type_classification/moveconstructible.h"
+#include "type_classification/swappable.h"
+
+using cuda::std::swappable;
+using cuda::std::swappable_with;
+
+template <class T, class U>
+__host__ __device__
+constexpr bool check_swappable_with_impl() {
+  static_assert(swappable_with<T, U> == swappable_with<U, T>);
+  return swappable_with<T, U>;
+}
+
+template <class T, class U>
+__host__ __device__
+constexpr bool check_swappable_with() {
+  static_assert(!check_swappable_with_impl<T, U>());
+  static_assert(!check_swappable_with_impl<T, U const>());
+  static_assert(!check_swappable_with_impl<T const, U>());
+  static_assert(!check_swappable_with_impl<T const, U const>());
+
+  static_assert(!check_swappable_with_impl<T, U&>());
+  static_assert(!check_swappable_with_impl<T, U const&>());
+  static_assert(!check_swappable_with_impl<T, U volatile&>());
+  static_assert(!check_swappable_with_impl<T, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const, U&>());
+  static_assert(!check_swappable_with_impl<T const, U const&>());
+  static_assert(!check_swappable_with_impl<T const, U volatile&>());
+  static_assert(!check_swappable_with_impl<T const, U const volatile&>());
+
+  static_assert(!check_swappable_with_impl<T&, U>());
+  static_assert(!check_swappable_with_impl<T&, U const>());
+  static_assert(!check_swappable_with_impl<T const&, U>());
+  static_assert(!check_swappable_with_impl<T const&, U const>());
+  static_assert(!check_swappable_with_impl<T volatile&, U>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U const>());
+
+  static_assert(!check_swappable_with_impl<T&, U const&>());
+  static_assert(!check_swappable_with_impl<T&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const&, U&>());
+  static_assert(!check_swappable_with_impl<T const&, U const&>());
+  static_assert(!check_swappable_with_impl<T const&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T const&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U const&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U volatile&>());
+  static_assert(
+      !check_swappable_with_impl<T const volatile&, U const volatile&>());
+
+  static_assert(!check_swappable_with_impl<T, U&&>());
+  static_assert(!check_swappable_with_impl<T, U const&&>());
+  static_assert(!check_swappable_with_impl<T, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const, U&&>());
+  static_assert(!check_swappable_with_impl<T const, U const&&>());
+  static_assert(!check_swappable_with_impl<T const, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T const, U const volatile&&>());
+
+  static_assert(!check_swappable_with_impl<T&&, U>());
+  static_assert(!check_swappable_with_impl<T&&, U const>());
+  static_assert(!check_swappable_with_impl<T const&&, U>());
+  static_assert(!check_swappable_with_impl<T const&&, U const>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U const>());
+
+  static_assert(!check_swappable_with_impl<T&, U&&>());
+  static_assert(!check_swappable_with_impl<T&, U const&&>());
+  static_assert(!check_swappable_with_impl<T&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const&, U&&>());
+  static_assert(!check_swappable_with_impl<T const&, U const&&>());
+  static_assert(!check_swappable_with_impl<T const&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T const&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U&&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const&&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T volatile&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U const&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&, U volatile&&>());
+  static_assert(
+      !check_swappable_with_impl<T const volatile&, U const volatile&&>());
+
+  static_assert(!check_swappable_with_impl<T&&, U&>());
+  static_assert(!check_swappable_with_impl<T&&, U const&>());
+  static_assert(!check_swappable_with_impl<T&&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T&&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const&&, U&>());
+  static_assert(!check_swappable_with_impl<T const&&, U const&>());
+  static_assert(!check_swappable_with_impl<T const&&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T const&&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U volatile&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const volatile&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U const&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U volatile&>());
+  static_assert(
+      !check_swappable_with_impl<T const volatile&&, U const volatile&>());
+
+  static_assert(!check_swappable_with_impl<T&&, U&&>());
+  static_assert(!check_swappable_with_impl<T&&, U const&&>());
+  static_assert(!check_swappable_with_impl<T&&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T&&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const&&, U&&>());
+  static_assert(!check_swappable_with_impl<T const&&, U const&&>());
+  static_assert(!check_swappable_with_impl<T const&&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T const&&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U&&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const&&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U volatile&&>());
+  static_assert(!check_swappable_with_impl<T volatile&&, U const volatile&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U const&&>());
+  static_assert(!check_swappable_with_impl<T const volatile&&, U volatile&&>());
+  static_assert(
+      !check_swappable_with_impl<T const volatile&&, U const volatile&&>());
+  return check_swappable_with_impl<T&, U&>();
+}
+
+template <class T, class U>
+__host__ __device__
+constexpr bool check_swappable_with_including_lvalue_ref_to_volatile() {
+  constexpr auto result = check_swappable_with<T, U>();
+  static_assert(check_swappable_with_impl<T volatile&, U volatile&>() ==
+                result);
+  return result;
+}
+
+namespace fundamental {
+static_assert(
+    check_swappable_with_including_lvalue_ref_to_volatile<int, int>());
+static_assert(
+    check_swappable_with_including_lvalue_ref_to_volatile<double, double>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int, double>());
+
+static_assert(
+    check_swappable_with_including_lvalue_ref_to_volatile<int*, int*>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int, int*>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (*)(), int (*)()>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int, int (*)()>());
+
+struct S {};
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int, S>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int S::*, int S::*>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int, int S::*>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)(), int (S::*)()>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int, int (S::*)()>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() noexcept, int (S::*)() noexcept>());
+#if TEST_STD_VER > 17
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() noexcept, int (S::*)()>());
+#endif // TEST_STD_VER > 17
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const, int (S::*)() const>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const, int (S::*)()>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const noexcept, int (S::*)() const noexcept>());
+#if TEST_STD_VER > 17
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const, int (S::*)() const noexcept>());
+#endif // TEST_STD_VER > 17
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() volatile, int (S::*)() volatile>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() volatile, int (S::*)()>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const volatile, int (S::*)() const volatile>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int (S::*)() const volatile, int (S::*)()>());
+
+static_assert(
+    check_swappable_with_including_lvalue_ref_to_volatile<int[5], int[5]>());
+static_assert(
+    !check_swappable_with_including_lvalue_ref_to_volatile<int[5], int[6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5], double[5]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5], double[6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int[5][6],
+                                                                     int[5]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int[5][6],
+                                                                     int[6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], double[5]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], double[6]>());
+static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], int[5][6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], int[5][4]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], int[6][5]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], double[5][6]>());
+static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
+              int[5][6], double[6][5]>());
+
+// always false
+static_assert(!check_swappable_with_impl<void, void>());
+static_assert(!check_swappable_with_impl<int, void>());
+static_assert(!check_swappable_with_impl<int&, void>());
+static_assert(!check_swappable_with_impl<void, int>());
+static_assert(!check_swappable_with_impl<void, int&>());
+static_assert(!check_swappable_with_impl<int, int()>());
+static_assert(!check_swappable_with_impl<int, int (&)()>());
+} // namespace fundamental
+
+namespace adl {
+static_assert(
+    check_swappable_with<lvalue_adl_swappable, lvalue_adl_swappable>());
+static_assert(check_swappable_with<lvalue_rvalue_adl_swappable,
+                                   lvalue_rvalue_adl_swappable>());
+static_assert(check_swappable_with<rvalue_lvalue_adl_swappable,
+                                   rvalue_lvalue_adl_swappable>());
+static_assert(
+    check_swappable_with_impl<rvalue_adl_swappable, rvalue_adl_swappable>());
+static_assert(!check_swappable_with_impl<lvalue_rvalue_adl_swappable&,
+                                         lvalue_rvalue_adl_swappable&&>());
+
+struct s1 {};
+struct no_common_reference_with_s1 {
+  __host__ __device__
+  friend void swap(s1&, no_common_reference_with_s1&);
+  __host__ __device__
+  friend void swap(no_common_reference_with_s1&, s1&);
+};
+static_assert(!check_swappable_with<s1, no_common_reference_with_s1>());
+
+struct one_way_swappable_with_s1 {
+  __host__ __device__
+  friend void swap(s1&, one_way_swappable_with_s1&);
+  __host__ __device__
+  operator s1();
+};
+static_assert(cuda::std::common_reference_with<one_way_swappable_with_s1, s1>);
+static_assert(!check_swappable_with<one_way_swappable_with_s1, s1>());
+
+struct one_way_swappable_with_s1_other_way {
+  __host__ __device__
+  friend void swap(one_way_swappable_with_s1_other_way&, s1&);
+  __host__ __device__
+  operator s1();
+};
+static_assert(
+    cuda::std::common_reference_with<one_way_swappable_with_s1_other_way, s1>);
+static_assert(!check_swappable_with<one_way_swappable_with_s1_other_way, s1>());
+
+struct can_swap_with_s1_but_not_swappable {
+  can_swap_with_s1_but_not_swappable(can_swap_with_s1_but_not_swappable&&) =
+      delete;
+  friend void swap(s1&, can_swap_with_s1_but_not_swappable&);
+  __host__ __device__
+  friend void swap(can_swap_with_s1_but_not_swappable&, s1&);
+
+  __host__ __device__
+  operator s1() const;
+};
+static_assert(
+    cuda::std::common_reference_with<can_swap_with_s1_but_not_swappable, s1>);
+static_assert(!swappable<can_swap_with_s1_but_not_swappable>);
+static_assert(
+    !check_swappable_with<can_swap_with_s1_but_not_swappable&, s1&>());
+
+struct swappable_with_s1 {
+  __host__ __device__
+  friend void swap(s1&, swappable_with_s1&);
+  __host__ __device__
+  friend void swap(swappable_with_s1&, s1&);
+  __host__ __device__
+  operator s1() const;
+};
+static_assert(check_swappable_with<swappable_with_s1, s1>());
+
+struct swappable_with_const_s1_but_not_swappable {
+  __host__ __device__
+  swappable_with_const_s1_but_not_swappable(
+      swappable_with_const_s1_but_not_swappable const&);
+  __host__ __device__
+  swappable_with_const_s1_but_not_swappable(
+      swappable_with_const_s1_but_not_swappable const&&);
+  __host__ __device__
+  swappable_with_const_s1_but_not_swappable&
+  operator=(swappable_with_const_s1_but_not_swappable const&);
+  __host__ __device__
+  swappable_with_const_s1_but_not_swappable&
+  operator=(swappable_with_const_s1_but_not_swappable const&&);
+
+  __host__ __device__
+  friend void swap(s1 const&, swappable_with_const_s1_but_not_swappable const&);
+  __host__ __device__
+  friend void swap(swappable_with_const_s1_but_not_swappable const&, s1 const&);
+
+  __host__ __device__
+  operator s1 const &() const;
+};
+static_assert(
+    !swappable<swappable_with_const_s1_but_not_swappable const&>);
+static_assert(!swappable_with<
+              swappable_with_const_s1_but_not_swappable const&, s1 const&>);
+
+struct swappable_with_volatile_s1_but_not_swappable {
+  __host__ __device__
+  swappable_with_volatile_s1_but_not_swappable(
+      swappable_with_volatile_s1_but_not_swappable volatile&);
+  __host__ __device__
+  swappable_with_volatile_s1_but_not_swappable(
+      swappable_with_volatile_s1_but_not_swappable volatile&&);
+  __host__ __device__
+  swappable_with_volatile_s1_but_not_swappable&
+  operator=(swappable_with_volatile_s1_but_not_swappable volatile&);
+  __host__ __device__
+  swappable_with_volatile_s1_but_not_swappable&
+  operator=(swappable_with_volatile_s1_but_not_swappable volatile&&);
+
+  __host__ __device__
+  friend void swap(s1 volatile&,
+                   swappable_with_volatile_s1_but_not_swappable volatile&);
+  __host__ __device__
+  friend void swap(swappable_with_volatile_s1_but_not_swappable volatile&,
+                   s1 volatile&);
+
+  __host__ __device__
+  operator s1 volatile &() volatile;
+};
+static_assert(
+    !swappable<swappable_with_volatile_s1_but_not_swappable volatile&>);
+static_assert(
+    !swappable_with<swappable_with_volatile_s1_but_not_swappable volatile&,
+                         s1 volatile&>);
+
+struct swappable_with_cv_s1_but_not_swappable {
+  __host__ __device__
+  swappable_with_cv_s1_but_not_swappable(
+      swappable_with_cv_s1_but_not_swappable const volatile&);
+  __host__ __device__
+  swappable_with_cv_s1_but_not_swappable(
+      swappable_with_cv_s1_but_not_swappable const volatile&&);
+  __host__ __device__
+  swappable_with_cv_s1_but_not_swappable&
+  operator=(swappable_with_cv_s1_but_not_swappable const volatile&);
+  __host__ __device__
+  swappable_with_cv_s1_but_not_swappable&
+  operator=(swappable_with_cv_s1_but_not_swappable const volatile&&);
+
+  __host__ __device__
+  friend void swap(s1 const volatile&,
+                   swappable_with_cv_s1_but_not_swappable const volatile&);
+  __host__ __device__
+  friend void swap(swappable_with_cv_s1_but_not_swappable const volatile&,
+                   s1 const volatile&);
+
+  __host__ __device__
+  operator s1 const volatile &() const volatile;
+};
+static_assert(
+    !swappable<swappable_with_cv_s1_but_not_swappable const volatile&>);
+static_assert(
+    !swappable_with<swappable_with_cv_s1_but_not_swappable const volatile&,
+                         s1 const volatile&>);
+
+struct s2 {
+  __host__ __device__
+  friend void swap(s2 const&, s2 const&);
+  __host__ __device__
+  friend void swap(s2 volatile&, s2 volatile&);
+  __host__ __device__
+  friend void swap(s2 const volatile&, s2 const volatile&);
+};
+
+struct swappable_with_const_s2 {
+  __host__ __device__
+  swappable_with_const_s2(swappable_with_const_s2 const&);
+  __host__ __device__
+  swappable_with_const_s2(swappable_with_const_s2 const&&);
+  __host__ __device__
+  swappable_with_const_s2& operator=(swappable_with_const_s2 const&);
+  __host__ __device__
+  swappable_with_const_s2& operator=(swappable_with_const_s2 const&&);
+
+  __host__ __device__
+  friend void swap(swappable_with_const_s2 const&,
+                   swappable_with_const_s2 const&);
+  __host__ __device__
+  friend void swap(s2 const&, swappable_with_const_s2 const&);
+  __host__ __device__
+  friend void swap(swappable_with_const_s2 const&, s2 const&);
+
+  __host__ __device__
+  operator s2 const &() const;
+};
+static_assert(swappable_with<swappable_with_const_s2 const&, s2 const&>);
+
+struct swappable_with_volatile_s2 {
+  __host__ __device__
+  swappable_with_volatile_s2(swappable_with_volatile_s2 volatile&);
+  __host__ __device__
+  swappable_with_volatile_s2(swappable_with_volatile_s2 volatile&&);
+  __host__ __device__
+  swappable_with_volatile_s2& operator=(swappable_with_volatile_s2 volatile&);
+  __host__ __device__
+  swappable_with_volatile_s2& operator=(swappable_with_volatile_s2 volatile&&);
+
+  __host__ __device__
+  friend void swap(swappable_with_volatile_s2 volatile&,
+                   swappable_with_volatile_s2 volatile&);
+  __host__ __device__
+  friend void swap(s2 volatile&, swappable_with_volatile_s2 volatile&);
+  __host__ __device__
+  friend void swap(swappable_with_volatile_s2 volatile&, s2 volatile&);
+
+  __host__ __device__
+  operator s2 volatile &() volatile;
+};
+using test = cuda::std::common_reference_t<swappable_with_volatile_s2 volatile&, s2 volatile&>;
+using test2 = cuda::std::common_reference_t<s2 volatile&, swappable_with_volatile_s2 volatile&>;
+static_assert(
+    cuda::std::_Common_reference_exists<swappable_with_volatile_s2 volatile&, s2 volatile&>);
+static_assert(
+    swappable_with<swappable_with_volatile_s2 volatile&, s2 volatile&>);
+
+struct swappable_with_cv_s2 {
+  __host__ __device__
+  swappable_with_cv_s2(swappable_with_cv_s2 const volatile&);
+  __host__ __device__
+  swappable_with_cv_s2(swappable_with_cv_s2 const volatile&&);
+  __host__ __device__
+  swappable_with_cv_s2& operator=(swappable_with_cv_s2 const volatile&);
+  __host__ __device__
+  swappable_with_cv_s2& operator=(swappable_with_cv_s2 const volatile&&);
+
+  __host__ __device__
+  friend void swap(swappable_with_cv_s2 const volatile&,
+                   swappable_with_cv_s2 const volatile&);
+  __host__ __device__
+  friend void swap(s2 const volatile&, swappable_with_cv_s2 const volatile&);
+  __host__ __device__
+  friend void swap(swappable_with_cv_s2 const volatile&, s2 const volatile&);
+
+  __host__ __device__
+  operator s2 const volatile &() const volatile;
+};
+static_assert(swappable_with<swappable_with_cv_s2 const volatile&,
+                                  s2 const volatile&>);
+
+struct swappable_with_rvalue_ref_to_s1_but_not_swappable {
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_s1_but_not_swappable&&,
+                   swappable_with_rvalue_ref_to_s1_but_not_swappable&&);
+  friend void swap(s1&&, swappable_with_rvalue_ref_to_s1_but_not_swappable&&);
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_s1_but_not_swappable&&, s1&&);
+
+  __host__ __device__
+  operator s1() const;
+};
+static_assert(
+    !swappable<swappable_with_rvalue_ref_to_s1_but_not_swappable const&&>);
+static_assert(
+    !swappable_with<
+        swappable_with_rvalue_ref_to_s1_but_not_swappable const&&, s1 const&&>);
+
+struct swappable_with_rvalue_ref_to_const_s1_but_not_swappable {
+  __host__ __device__
+  friend void
+  swap(s1 const&&,
+       swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&);
+  __host__ __device__
+  friend void
+  swap(swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&,
+       s1 const&&);
+
+  __host__ __device__
+  operator s1 const() const;
+};
+static_assert(!swappable<
+              swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&>);
+static_assert(!swappable_with<
+              swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&,
+              s1 const&&>);
+
+struct swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable {
+  __host__ __device__
+  swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable(
+      swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable(
+      swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable& operator=(
+      swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&);
+  __host__ __device__
+  __host__ __device__
+  swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable& operator=(
+      swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
+
+  __host__ __device__
+  friend void
+  swap(s1 volatile&&,
+       swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
+  __host__ __device__
+  friend void
+  swap(swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&,
+       s1 volatile&&);
+
+  __host__ __device__
+  operator s1 volatile &&() volatile&&;
+};
+static_assert(
+    !swappable<
+        swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&>);
+static_assert(
+    !swappable_with<
+        swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&,
+        s1 volatile&&>);
+
+struct swappable_with_rvalue_ref_to_cv_s1_but_not_swappable {
+  __host__ __device__
+  swappable_with_rvalue_ref_to_cv_s1_but_not_swappable(
+      swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_cv_s1_but_not_swappable(
+      swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_cv_s1_but_not_swappable& operator=(
+      swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_cv_s1_but_not_swappable& operator=(
+      swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
+
+  __host__ __device__
+  friend void
+  swap(s1 const volatile&&,
+       swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
+  __host__ __device__
+  friend void
+  swap(swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&,
+       s1 const volatile&&);
+
+  __host__ __device__
+  operator s1 const volatile &&() const volatile&&;
+};
+static_assert(
+    !swappable<
+        swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&>);
+static_assert(
+    !swappable_with<
+        swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&,
+        s1 const volatile&&>);
+
+struct s3 {
+  __host__ __device__
+  friend void swap(s3&&, s3&&);
+  __host__ __device__
+  friend void swap(s3 const&&, s3 const&&);
+  __host__ __device__
+  friend void swap(s3 volatile&&, s3 volatile&&);
+  __host__ __device__
+  friend void swap(s3 const volatile&&, s3 const volatile&&);
+};
+
+struct swappable_with_rvalue_ref_to_s3 {
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_s3&&,
+                   swappable_with_rvalue_ref_to_s3&&);
+  __host__ __device__
+  friend void swap(s3&&, swappable_with_rvalue_ref_to_s3&&);
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_s3&&, s3&&);
+
+  __host__ __device__
+  operator s3() const;
+};
+static_assert(swappable_with<swappable_with_rvalue_ref_to_s3&&, s3&&>);
+
+struct swappable_with_rvalue_ref_to_const_s3 {
+  __host__ __device__
+  swappable_with_rvalue_ref_to_const_s3(
+      swappable_with_rvalue_ref_to_const_s3 const&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_const_s3(
+      swappable_with_rvalue_ref_to_const_s3 const&&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_const_s3&
+  operator=(swappable_with_rvalue_ref_to_const_s3 const&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_const_s3&
+  operator=(swappable_with_rvalue_ref_to_const_s3 const&&);
+
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_const_s3 const&&,
+                   swappable_with_rvalue_ref_to_const_s3 const&&);
+  __host__ __device__
+  friend void swap(s3 const&&, swappable_with_rvalue_ref_to_const_s3 const&&);
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_const_s3 const&&, s3 const&&);
+
+  __host__ __device__
+  operator s3() const;
+};
+static_assert(swappable_with<swappable_with_rvalue_ref_to_const_s3 const&&,
+                                  s3 const&&>);
+
+struct swappable_with_rvalue_ref_to_volatile_s3 {
+  __host__ __device__
+  swappable_with_rvalue_ref_to_volatile_s3(
+      swappable_with_rvalue_ref_to_volatile_s3 volatile&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_volatile_s3(
+      swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_volatile_s3&
+  operator=(swappable_with_rvalue_ref_to_volatile_s3 volatile&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_volatile_s3&
+  operator=(swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
+
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
+                   swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
+  __host__ __device__
+  friend void swap(s3 volatile&&,
+                   swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
+                   s3 volatile&&);
+
+  __host__ __device__
+  operator s3 volatile &&() volatile;
+};
+static_assert(
+    swappable_with<swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
+                        s3 volatile&&>);
+
+struct swappable_with_rvalue_ref_to_cv_s3 {
+  __host__ __device__
+  swappable_with_rvalue_ref_to_cv_s3(
+      swappable_with_rvalue_ref_to_cv_s3 const volatile&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_cv_s3(
+      swappable_with_rvalue_ref_to_cv_s3 const volatile&&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_cv_s3&
+  operator=(swappable_with_rvalue_ref_to_cv_s3 const volatile&);
+  __host__ __device__
+  swappable_with_rvalue_ref_to_cv_s3&
+  operator=(swappable_with_rvalue_ref_to_cv_s3 const volatile&&);
+
+  friend void swap(swappable_with_rvalue_ref_to_cv_s3 const volatile&&,
+                   swappable_with_rvalue_ref_to_cv_s3 const volatile&&);
+  __host__ __device__
+  friend void swap(s3 const volatile&&,
+                   swappable_with_rvalue_ref_to_cv_s3 const volatile&&);
+  __host__ __device__
+  friend void swap(swappable_with_rvalue_ref_to_cv_s3 const volatile&&,
+                   s3 const volatile&&);
+
+  __host__ __device__
+  operator s3 const volatile &&() const volatile;
+};
+static_assert(cuda::std::common_reference_with<swappable_with_rvalue_ref_to_cv_s3 const volatile&&,
+                        s3 const volatile&&>);
+static_assert(
+    swappable_with<swappable_with_rvalue_ref_to_cv_s3 const volatile&&,
+                        s3 const volatile&&>);
+
+namespace union_swap {
+union adl_swappable {
+  int x;
+  double y;
+
+  __host__ __device__
+  operator int() const;
+};
+
+__host__ __device__
+void swap(adl_swappable&, adl_swappable&) noexcept;
+__host__ __device__
+void swap(adl_swappable&&, adl_swappable&&) noexcept;
+__host__ __device__
+void swap(adl_swappable&, int&) noexcept;
+__host__ __device__
+void swap(int&, adl_swappable&) noexcept;
+} // namespace union_swap
+static_assert(
+    swappable_with<union_swap::adl_swappable, union_swap::adl_swappable>);
+static_assert(swappable_with<union_swap::adl_swappable&,
+                                  union_swap::adl_swappable&>);
+static_assert(swappable_with<union_swap::adl_swappable&&,
+                                  union_swap::adl_swappable&&>);
+static_assert(swappable_with<union_swap::adl_swappable&, int&>);
+} // namespace adl
+
+namespace standard_types {
+static_assert(
+    check_swappable_with<std::array<int, 10>, std::array<int, 10> >());
+static_assert(
+    !check_swappable_with<std::array<int, 10>, std::array<double, 10> >());
+} // namespace standard_types
+
+namespace types_with_purpose {
+static_assert(!check_swappable_with<DeletedMoveCtor, DeletedMoveCtor>());
+static_assert(!check_swappable_with<ImplicitlyDeletedMoveCtor,
+                                    ImplicitlyDeletedMoveCtor>());
+static_assert(!check_swappable_with<DeletedMoveAssign, DeletedMoveAssign>());
+static_assert(!check_swappable_with<ImplicitlyDeletedMoveAssign,
+                                    ImplicitlyDeletedMoveAssign>());
+static_assert(!check_swappable_with<NonMovable, NonMovable>());
+static_assert(
+    !check_swappable_with<DerivedFromNonMovable, DerivedFromNonMovable>());
+static_assert(!check_swappable_with<HasANonMovable, HasANonMovable>());
+} // namespace types_with_purpose
+
+namespace LWG3175 {
+// Example taken directly from [concept.swappable]
+_LIBCUDACXX_TEMPLATE(class T, class U)
+  (requires swappable_with<T, U>)
+__host__ __device__
+constexpr void value_swap(T&& t, U&& u) {
+  cuda::std::ranges::swap(std::forward<T>(t), std::forward<U>(u));
+}
+
+_LIBCUDACXX_TEMPLATE(class T)
+  (requires swappable<T>)
+__host__ __device__
+constexpr void lv_swap(T& t1, T& t2) {
+  cuda::std::ranges::swap(t1, t2);
+}
+
+namespace N {
+struct A {
+  int m;
+};
+struct Proxy {
+  A* a;
+  __host__ __device__
+  constexpr Proxy(A& a_) : a{&a_} {}
+  __host__ __device__
+  friend constexpr void swap(Proxy x, Proxy y) {
+    cuda::std::ranges::swap(*x.a, *y.a);
+  }
+};
+__host__ __device__
+constexpr Proxy proxy(A& a) { return Proxy{a}; }
+} // namespace N
+__host__ __device__
+constexpr bool CheckRegression() {
+  int i = 1, j = 2;
+  lv_swap(i, j);
+  assert(i == 2 && j == 1);
+
+  N::A a1 = {5}, a2 = {-5};
+  value_swap(a1, proxy(a2));
+  assert(a1.m == -5 && a2.m == 5);
+  return true;
+}
+
+static_assert(CheckRegression());
+} // namespace LWG3175
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/arithmetic.h b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/arithmetic.h
new file mode 100644
index 0000000000..178e91bd08
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/arithmetic.h
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_
+#define LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_
+
+#include <cuda/std/concepts>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER > 17
+// This overload should never be called. It exists solely to force subsumption.
+template <cuda::std::integral I>
+constexpr bool CheckSubsumption(I) {
+  return false;
+}
+
+template <cuda::std::integral I>
+requires cuda::std::signed_integral<I> && (!cuda::std::unsigned_integral<I>)
+constexpr bool CheckSubsumption(I) {
+  return cuda::std::is_signed_v<I>;
+}
+
+template <cuda::std::integral I>
+requires cuda::std::unsigned_integral<I> && (!cuda::std::signed_integral<I>)
+constexpr bool CheckSubsumption(I) {
+  return cuda::std::is_unsigned_v<I>;
+}
+#endif // TEST_STD_VER > 17
+
+enum ClassicEnum { a, b, c };
+enum class ScopedEnum { x, y, z };
+struct EmptyStruct {};
+
+#endif // LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/floating_point.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/floating_point.pass.cpp
new file mode 100644
index 0000000000..2e10dc4290
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/floating_point.pass.cpp
@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept floating_point = // see below
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "test_macros.h"
+#include "arithmetic.h"
+
+using cuda::std::floating_point;
+
+template <typename T>
+constexpr bool CheckFloatingPointQualifiers() {
+  constexpr bool result = floating_point<T>;
+  static_assert(floating_point<const T> == result);
+  static_assert(floating_point<volatile T> == result);
+  static_assert(floating_point<const volatile T> == result);
+
+  static_assert(!floating_point<T&>);
+  static_assert(!floating_point<const T&>);
+  static_assert(!floating_point<volatile T&>);
+  static_assert(!floating_point<const volatile T&>);
+
+  static_assert(!floating_point<T&&>);
+  static_assert(!floating_point<const T&&>);
+  static_assert(!floating_point<volatile T&&>);
+  static_assert(!floating_point<const volatile T&&>);
+
+  static_assert(!floating_point<T*>);
+  static_assert(!floating_point<const T*>);
+  static_assert(!floating_point<volatile T*>);
+  static_assert(!floating_point<const volatile T*>);
+
+  static_assert(!floating_point<T (*)()>);
+  static_assert(!floating_point<T (&)()>);
+  static_assert(!floating_point<T(&&)()>);
+
+  return result;
+}
+
+// floating-point types
+static_assert(CheckFloatingPointQualifiers<float>());
+static_assert(CheckFloatingPointQualifiers<double>());
+static_assert(CheckFloatingPointQualifiers<long double>());
+
+// types that aren't floating-point
+static_assert(!CheckFloatingPointQualifiers<signed char>());
+static_assert(!CheckFloatingPointQualifiers<unsigned char>());
+static_assert(!CheckFloatingPointQualifiers<short>());
+static_assert(!CheckFloatingPointQualifiers<unsigned short>());
+static_assert(!CheckFloatingPointQualifiers<int>());
+static_assert(!CheckFloatingPointQualifiers<unsigned int>());
+static_assert(!CheckFloatingPointQualifiers<long>());
+static_assert(!CheckFloatingPointQualifiers<unsigned long>());
+static_assert(!CheckFloatingPointQualifiers<long long>());
+static_assert(!CheckFloatingPointQualifiers<unsigned long long>());
+static_assert(!CheckFloatingPointQualifiers<wchar_t>());
+static_assert(!CheckFloatingPointQualifiers<bool>());
+static_assert(!CheckFloatingPointQualifiers<char>());
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(!CheckFloatingPointQualifiers<char8_t>());
+#endif // TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(!CheckFloatingPointQualifiers<char16_t>());
+static_assert(!CheckFloatingPointQualifiers<char32_t>());
+static_assert(!floating_point<void>);
+
+static_assert(!CheckFloatingPointQualifiers<ClassicEnum>());
+static_assert(!CheckFloatingPointQualifiers<ScopedEnum>());
+static_assert(!CheckFloatingPointQualifiers<EmptyStruct>());
+static_assert(!CheckFloatingPointQualifiers<int EmptyStruct::*>());
+static_assert(!CheckFloatingPointQualifiers<int (EmptyStruct::*)()>());
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/integral.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/integral.pass.cpp
new file mode 100644
index 0000000000..d7c60c32d0
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/integral.pass.cpp
@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept integral = // see below
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "test_macros.h"
+#include "arithmetic.h"
+
+using cuda::std::integral;
+
+template <typename T>
+__host__ __device__
+constexpr bool CheckIntegralQualifiers() {
+  constexpr bool result = integral<T>;
+  static_assert(integral<const T> == result);
+  static_assert(integral<volatile T> == result);
+  static_assert(integral<const volatile T> == result);
+
+  static_assert(!integral<T&>);
+  static_assert(!integral<const T&>);
+  static_assert(!integral<volatile T&>);
+  static_assert(!integral<const volatile T&>);
+
+  static_assert(!integral<T&&>);
+  static_assert(!integral<const T&&>);
+  static_assert(!integral<volatile T&&>);
+  static_assert(!integral<const volatile T&&>);
+
+  static_assert(!integral<T*>);
+  static_assert(!integral<const T*>);
+  static_assert(!integral<volatile T*>);
+  static_assert(!integral<const volatile T*>);
+
+  static_assert(!integral<T (*)()>);
+  static_assert(!integral<T (&)()>);
+  static_assert(!integral<T(&&)()>);
+
+  return result;
+}
+
+// standard signed and unsigned integers
+static_assert(CheckIntegralQualifiers<signed char>());
+static_assert(CheckIntegralQualifiers<unsigned char>());
+static_assert(CheckIntegralQualifiers<short>());
+static_assert(CheckIntegralQualifiers<unsigned short>());
+static_assert(CheckIntegralQualifiers<int>());
+static_assert(CheckIntegralQualifiers<unsigned int>());
+static_assert(CheckIntegralQualifiers<long>());
+static_assert(CheckIntegralQualifiers<unsigned long>());
+static_assert(CheckIntegralQualifiers<long long>());
+static_assert(CheckIntegralQualifiers<unsigned long long>());
+
+// extended integers
+#ifndef TEST_HAS_NO_INT128
+static_assert(CheckIntegralQualifiers<__int128_t>());
+static_assert(CheckIntegralQualifiers<__uint128_t>());
+#endif
+
+// bool and char types are also integral
+static_assert(CheckIntegralQualifiers<wchar_t>());
+static_assert(CheckIntegralQualifiers<bool>());
+static_assert(CheckIntegralQualifiers<char>());
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(CheckIntegralQualifiers<char8_t>());
+#endif // TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(CheckIntegralQualifiers<char16_t>());
+static_assert(CheckIntegralQualifiers<char32_t>());
+
+// types that aren't integral
+static_assert(!integral<void>);
+static_assert(!CheckIntegralQualifiers<float>());
+static_assert(!CheckIntegralQualifiers<double>());
+static_assert(!CheckIntegralQualifiers<long double>());
+
+static_assert(!CheckIntegralQualifiers<ClassicEnum>());
+
+static_assert(!CheckIntegralQualifiers<ScopedEnum>());
+
+static_assert(!CheckIntegralQualifiers<EmptyStruct>());
+static_assert(!CheckIntegralQualifiers<int EmptyStruct::*>());
+static_assert(!CheckIntegralQualifiers<int (EmptyStruct::*)()>());
+
+#if TEST_STD_VER > 17
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+#endif // TEST_STD_VER > 17
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.pass.cpp
new file mode 100644
index 0000000000..0da125fd17
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept signed_integral = // see below
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "test_macros.h"
+#include "arithmetic.h"
+
+using cuda::std::signed_integral;
+
+template <typename T>
+__host__ __device__
+constexpr bool CheckSignedIntegralQualifiers() {
+  constexpr bool result = signed_integral<T>;
+  static_assert(signed_integral<const T> == result);
+  static_assert(signed_integral<volatile T> == result);
+  static_assert(signed_integral<const volatile T> == result);
+
+  static_assert(!signed_integral<T&>);
+  static_assert(!signed_integral<const T&>);
+  static_assert(!signed_integral<volatile T&>);
+  static_assert(!signed_integral<const volatile T&>);
+
+  static_assert(!signed_integral<T&&>);
+  static_assert(!signed_integral<const T&&>);
+  static_assert(!signed_integral<volatile T&&>);
+  static_assert(!signed_integral<const volatile T&&>);
+
+  static_assert(!signed_integral<T*>);
+  static_assert(!signed_integral<const T*>);
+  static_assert(!signed_integral<volatile T*>);
+  static_assert(!signed_integral<const volatile T*>);
+
+  static_assert(!signed_integral<T (*)()>);
+  static_assert(!signed_integral<T (&)()>);
+  static_assert(!signed_integral<T(&&)()>);
+
+  return result;
+}
+
+// standard signed integers
+static_assert(CheckSignedIntegralQualifiers<signed char>());
+static_assert(CheckSignedIntegralQualifiers<short>());
+static_assert(CheckSignedIntegralQualifiers<int>());
+static_assert(CheckSignedIntegralQualifiers<long>());
+static_assert(CheckSignedIntegralQualifiers<long long>());
+
+// bool and character *may* be signed
+static_assert(CheckSignedIntegralQualifiers<wchar_t>() ==
+              cuda::std::is_signed_v<wchar_t>);
+static_assert(CheckSignedIntegralQualifiers<bool>() == cuda::std::is_signed_v<bool>);
+static_assert(CheckSignedIntegralQualifiers<char>() == cuda::std::is_signed_v<char>);
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(CheckSignedIntegralQualifiers<char8_t>() ==
+              cuda::std::is_signed_v<char8_t>);
+#endif // TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(CheckSignedIntegralQualifiers<char16_t>() ==
+              cuda::std::is_signed_v<char16_t>);
+static_assert(CheckSignedIntegralQualifiers<char32_t>() ==
+              cuda::std::is_signed_v<char32_t>);
+
+// integers that aren't signed integrals
+static_assert(!CheckSignedIntegralQualifiers<unsigned char>());
+static_assert(!CheckSignedIntegralQualifiers<unsigned short>());
+static_assert(!CheckSignedIntegralQualifiers<unsigned int>());
+static_assert(!CheckSignedIntegralQualifiers<unsigned long>());
+static_assert(!CheckSignedIntegralQualifiers<unsigned long long>());
+
+// extended integers
+#ifndef TEST_HAS_NO_INT128
+static_assert(CheckSignedIntegralQualifiers<__int128_t>());
+static_assert(!CheckSignedIntegralQualifiers<__uint128_t>());
+#endif
+
+// types that aren't even integers shouldn't be signed integers!
+static_assert(!signed_integral<void>);
+static_assert(!CheckSignedIntegralQualifiers<float>());
+static_assert(!CheckSignedIntegralQualifiers<double>());
+static_assert(!CheckSignedIntegralQualifiers<long double>());
+
+static_assert(!CheckSignedIntegralQualifiers<ClassicEnum>());
+static_assert(!CheckSignedIntegralQualifiers<ScopedEnum>());
+static_assert(!CheckSignedIntegralQualifiers<EmptyStruct>());
+static_assert(!CheckSignedIntegralQualifiers<int EmptyStruct::*>());
+static_assert(!CheckSignedIntegralQualifiers<int (EmptyStruct::*)()>());
+
+#if TEST_STD_VER > 17
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+#endif // TEST_STD_VER > 17
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.pass.cpp b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.pass.cpp
new file mode 100644
index 0000000000..b003e33cda
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.pass.cpp
@@ -0,0 +1,105 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept unsigned_integral = // see below
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+#include "test_macros.h"
+#include "arithmetic.h"
+
+using cuda::std::unsigned_integral;
+
+template <typename T>
+__host__ __device__
+constexpr bool CheckUnsignedIntegralQualifiers() {
+  constexpr bool result = unsigned_integral<T>;
+  static_assert(unsigned_integral<const T> == result);
+  static_assert(unsigned_integral<volatile T> == result);
+  static_assert(unsigned_integral<const volatile T> == result);
+
+  static_assert(!unsigned_integral<T&>);
+  static_assert(!unsigned_integral<const T&>);
+  static_assert(!unsigned_integral<volatile T&>);
+  static_assert(!unsigned_integral<const volatile T&>);
+
+  static_assert(!unsigned_integral<T&&>);
+  static_assert(!unsigned_integral<const T&&>);
+  static_assert(!unsigned_integral<volatile T&&>);
+  static_assert(!unsigned_integral<const volatile T&&>);
+
+  static_assert(!unsigned_integral<T*>);
+  static_assert(!unsigned_integral<const T*>);
+  static_assert(!unsigned_integral<volatile T*>);
+  static_assert(!unsigned_integral<const volatile T*>);
+
+  static_assert(!unsigned_integral<T (*)()>);
+  static_assert(!unsigned_integral<T (&)()>);
+  static_assert(!unsigned_integral<T(&&)()>);
+
+  return result;
+}
+
+// standard unsigned types
+static_assert(CheckUnsignedIntegralQualifiers<unsigned char>());
+static_assert(CheckUnsignedIntegralQualifiers<unsigned short>());
+static_assert(CheckUnsignedIntegralQualifiers<unsigned int>());
+static_assert(CheckUnsignedIntegralQualifiers<unsigned long>());
+static_assert(CheckUnsignedIntegralQualifiers<unsigned long long>());
+
+// Whether bool and character types are signed or unsigned is impl-defined
+static_assert(CheckUnsignedIntegralQualifiers<wchar_t>() ==
+              !cuda::std::is_signed_v<wchar_t>);
+static_assert(CheckUnsignedIntegralQualifiers<bool>() ==
+              !cuda::std::is_signed_v<bool>);
+static_assert(CheckUnsignedIntegralQualifiers<char>() ==
+              !cuda::std::is_signed_v<char>);
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(CheckUnsignedIntegralQualifiers<char8_t>() ==
+              !cuda::std::is_signed_v<char8_t>);
+#endif // TEST_STD_VER > 17 && defined(__cpp_char8_t)
+static_assert(CheckUnsignedIntegralQualifiers<char16_t>() ==
+              !cuda::std::is_signed_v<char16_t>);
+static_assert(CheckUnsignedIntegralQualifiers<char32_t>() ==
+              !cuda::std::is_signed_v<char32_t>);
+
+// extended integers
+#ifndef TEST_HAS_NO_INT128
+static_assert(CheckUnsignedIntegralQualifiers<__uint128_t>());
+static_assert(!CheckUnsignedIntegralQualifiers<__int128_t>());
+#endif
+
+// integer types that aren't unsigned integrals
+static_assert(!CheckUnsignedIntegralQualifiers<signed char>());
+static_assert(!CheckUnsignedIntegralQualifiers<short>());
+static_assert(!CheckUnsignedIntegralQualifiers<int>());
+static_assert(!CheckUnsignedIntegralQualifiers<long>());
+static_assert(!CheckUnsignedIntegralQualifiers<long long>());
+
+static_assert(!unsigned_integral<void>);
+static_assert(!CheckUnsignedIntegralQualifiers<float>());
+static_assert(!CheckUnsignedIntegralQualifiers<double>());
+static_assert(!CheckUnsignedIntegralQualifiers<long double>());
+
+static_assert(!CheckUnsignedIntegralQualifiers<ClassicEnum>());
+static_assert(!CheckUnsignedIntegralQualifiers<ScopedEnum>());
+static_assert(!CheckUnsignedIntegralQualifiers<EmptyStruct>());
+static_assert(!CheckUnsignedIntegralQualifiers<int EmptyStruct::*>());
+static_assert(!CheckUnsignedIntegralQualifiers<int (EmptyStruct::*)()>());
+
+#if TEST_STD_VER > 17
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+#endif // TEST_STD_VER > 17
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.object/copyable.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.object/copyable.compile.pass.cpp
new file mode 100644
index 0000000000..6072bb0eca
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.object/copyable.compile.pass.cpp
@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept copyable = see below;
+
+#include <cuda/std/concepts>
+
+#include "type_classification/copyable.h"
+
+using cuda::std::copyable;
+
+static_assert(copyable<int>);
+static_assert(copyable<int volatile>);
+static_assert(copyable<int*>);
+static_assert(copyable<int const*>);
+static_assert(copyable<int volatile*>);
+static_assert(copyable<int volatile const*>);
+static_assert(copyable<int (*)()>);
+
+struct S {};
+static_assert(copyable<S>);
+static_assert(copyable<int S::*>);
+static_assert(copyable<int (S::*)()>);
+static_assert(copyable<int (S::*)() noexcept>);
+static_assert(copyable<int (S::*)() &>);
+static_assert(copyable<int (S::*)() & noexcept>);
+static_assert(copyable<int (S::*)() &&>);
+static_assert(copyable<int (S::*)() && noexcept>);
+static_assert(copyable<int (S::*)() const>);
+static_assert(copyable<int (S::*)() const noexcept>);
+static_assert(copyable<int (S::*)() const&>);
+static_assert(copyable<int (S::*)() const & noexcept>);
+static_assert(copyable<int (S::*)() const&&>);
+static_assert(copyable<int (S::*)() const && noexcept>);
+static_assert(copyable<int (S::*)() volatile>);
+static_assert(copyable<int (S::*)() volatile noexcept>);
+static_assert(copyable<int (S::*)() volatile&>);
+static_assert(copyable<int (S::*)() volatile & noexcept>);
+static_assert(copyable<int (S::*)() volatile&&>);
+static_assert(copyable<int (S::*)() volatile && noexcept>);
+static_assert(copyable<int (S::*)() const volatile>);
+static_assert(copyable<int (S::*)() const volatile noexcept>);
+static_assert(copyable<int (S::*)() const volatile&>);
+static_assert(copyable<int (S::*)() const volatile & noexcept>);
+static_assert(copyable<int (S::*)() const volatile&&>);
+static_assert(copyable<int (S::*)() const volatile && noexcept>);
+
+static_assert(copyable<has_volatile_member>);
+static_assert(copyable<has_array_member>);
+
+// Not objects
+static_assert(!copyable<void>);
+static_assert(!copyable<int&>);
+static_assert(!copyable<int const&>);
+static_assert(!copyable<int volatile&>);
+static_assert(!copyable<int const volatile&>);
+static_assert(!copyable<int&&>);
+static_assert(!copyable<int const&&>);
+static_assert(!copyable<int volatile&&>);
+static_assert(!copyable<int const volatile&&>);
+static_assert(!copyable<int()>);
+static_assert(!copyable<int (&)()>);
+static_assert(!copyable<int[5]>);
+
+// Not assignable
+static_assert(!copyable<int const>);
+static_assert(!copyable<int const volatile>);
+static_assert(copyable<const_copy_assignment const>);
+static_assert(!copyable<volatile_copy_assignment volatile>);
+static_assert(copyable<cv_copy_assignment const volatile>);
+
+static_assert(!copyable<no_copy_constructor>);
+static_assert(!copyable<no_copy_assignment>);
+
+static_assert(cuda::std::is_copy_assignable_v<no_copy_assignment_mutable>);
+static_assert(!copyable<no_copy_assignment_mutable>);
+static_assert(!copyable<derived_from_noncopyable>);
+static_assert(!copyable<has_noncopyable>);
+static_assert(!copyable<has_const_member>);
+static_assert(!copyable<has_cv_member>);
+static_assert(!copyable<has_lvalue_reference_member>);
+static_assert(!copyable<has_rvalue_reference_member>);
+static_assert(!copyable<has_function_ref_member>);
+
+static_assert(
+    !cuda::std::assignable_from<deleted_assignment_from_const_rvalue&,
+                          deleted_assignment_from_const_rvalue const>);
+static_assert(!copyable<deleted_assignment_from_const_rvalue>);
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.object/movable.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.object/movable.compile.pass.cpp
new file mode 100644
index 0000000000..b7c2938bbc
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.object/movable.compile.pass.cpp
@@ -0,0 +1,122 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept movable = see below;
+
+#include <cuda/std/concepts>
+
+#include "test_macros.h"
+
+#include "type_classification/moveconstructible.h"
+#include "type_classification/movable.h"
+
+using cuda::std::movable;
+
+// Movable types
+static_assert(movable<int>);
+static_assert(movable<int volatile>);
+static_assert(movable<int*>);
+static_assert(movable<int const*>);
+static_assert(movable<int volatile*>);
+static_assert(movable<int const volatile*>);
+static_assert(movable<int (*)()>);
+
+struct S {};
+static_assert(movable<S>);
+static_assert(movable<int S::*>);
+static_assert(movable<int (S::*)()>);
+static_assert(movable<int (S::*)() noexcept>);
+static_assert(movable<int (S::*)() &>);
+static_assert(movable<int (S::*)() & noexcept>);
+static_assert(movable<int (S::*)() &&>);
+static_assert(movable<int (S::*)() && noexcept>);
+static_assert(movable<int (S::*)() const>);
+static_assert(movable<int (S::*)() const noexcept>);
+static_assert(movable<int (S::*)() const&>);
+static_assert(movable<int (S::*)() const & noexcept>);
+static_assert(movable<int (S::*)() const&&>);
+static_assert(movable<int (S::*)() const && noexcept>);
+static_assert(movable<int (S::*)() volatile>);
+static_assert(movable<int (S::*)() volatile noexcept>);
+static_assert(movable<int (S::*)() volatile&>);
+static_assert(movable<int (S::*)() volatile & noexcept>);
+static_assert(movable<int (S::*)() volatile&&>);
+static_assert(movable<int (S::*)() volatile && noexcept>);
+static_assert(movable<int (S::*)() const volatile>);
+static_assert(movable<int (S::*)() const volatile noexcept>);
+static_assert(movable<int (S::*)() const volatile&>);
+static_assert(movable<int (S::*)() const volatile & noexcept>);
+static_assert(movable<int (S::*)() const volatile&&>);
+static_assert(movable<int (S::*)() const volatile && noexcept>);
+
+static_assert(movable<has_volatile_member>);
+static_assert(movable<has_array_member>);
+
+// Not objects
+static_assert(!movable<int&>);
+static_assert(!movable<int const&>);
+static_assert(!movable<int volatile&>);
+static_assert(!movable<int const volatile&>);
+static_assert(!movable<int&&>);
+static_assert(!movable<int const&&>);
+static_assert(!movable<int volatile&&>);
+static_assert(!movable<int const volatile&&>);
+static_assert(!movable<int()>);
+static_assert(!movable<int (&)()>);
+static_assert(!movable<int[5]>);
+
+// Core non-move assignable.
+static_assert(!movable<int const>);
+static_assert(!movable<int const volatile>);
+
+static_assert(!movable<DeletedMoveCtor>);
+static_assert(!movable<ImplicitlyDeletedMoveCtor>);
+static_assert(!movable<DeletedMoveAssign>);
+static_assert(!movable<ImplicitlyDeletedMoveAssign>);
+static_assert(!movable<NonMovable>);
+static_assert(!movable<DerivedFromNonMovable>);
+static_assert(!movable<HasANonMovable>);
+
+static_assert(movable<cpp03_friendly>);
+static_assert(movable<const_move_ctor>);
+static_assert(movable<volatile_move_ctor>);
+static_assert(movable<cv_move_ctor>);
+static_assert(movable<multi_param_move_ctor>);
+static_assert(!movable<not_quite_multi_param_move_ctor>);
+
+static_assert(!cuda::std::assignable_from<copy_with_mutable_parameter&,
+                                    copy_with_mutable_parameter>);
+static_assert(!movable<copy_with_mutable_parameter>);
+
+static_assert(!movable<const_move_assignment>);
+static_assert(movable<volatile_move_assignment>);
+static_assert(!movable<cv_move_assignment>);
+
+static_assert(!movable<const_move_assign_and_traditional_move_assign>);
+static_assert(!movable<volatile_move_assign_and_traditional_move_assign>);
+static_assert(!movable<cv_move_assign_and_traditional_move_assign>);
+static_assert(movable<const_move_assign_and_default_ops>);
+static_assert(movable<volatile_move_assign_and_default_ops>);
+static_assert(movable<cv_move_assign_and_default_ops>);
+
+static_assert(!movable<has_const_member>);
+static_assert(!movable<has_cv_member>);
+static_assert(!movable<has_lvalue_reference_member>);
+static_assert(!movable<has_rvalue_reference_member>);
+static_assert(!movable<has_function_ref_member>);
+
+static_assert(movable<deleted_assignment_from_const_rvalue>);
+
+// `move_constructible and assignable_from<T&, T>` implies `swappable<T>`,
+// so there's nothing to test for the case of non-swappable.
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.object/regular.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.object/regular.compile.pass.cpp
new file mode 100644
index 0000000000..6cdfbf4e02
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.object/regular.compile.pass.cpp
@@ -0,0 +1,144 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept regular = see below;
+
+#include <cuda/std/concepts>
+
+#include "type_classification/moveconstructible.h"
+#include "type_classification/semiregular.h"
+
+using cuda::std::regular;
+
+static_assert(regular<int>);
+static_assert(regular<float>);
+static_assert(regular<double>);
+static_assert(regular<long double>);
+static_assert(regular<int volatile>);
+static_assert(regular<void*>);
+static_assert(regular<int*>);
+static_assert(regular<int const*>);
+static_assert(regular<int volatile*>);
+static_assert(regular<int volatile const*>);
+static_assert(regular<int (*)()>);
+
+struct S {};
+static_assert(!regular<S>);
+static_assert(regular<int S::*>);
+static_assert(regular<int (S::*)()>);
+static_assert(regular<int (S::*)() noexcept>);
+static_assert(regular<int (S::*)() &>);
+static_assert(regular<int (S::*)() & noexcept>);
+static_assert(regular<int (S::*)() &&>);
+static_assert(regular<int (S::*)() && noexcept>);
+static_assert(regular<int (S::*)() const>);
+static_assert(regular<int (S::*)() const noexcept>);
+static_assert(regular<int (S::*)() const&>);
+static_assert(regular<int (S::*)() const & noexcept>);
+static_assert(regular<int (S::*)() const&&>);
+static_assert(regular<int (S::*)() const && noexcept>);
+static_assert(regular<int (S::*)() volatile>);
+static_assert(regular<int (S::*)() volatile noexcept>);
+static_assert(regular<int (S::*)() volatile&>);
+static_assert(regular<int (S::*)() volatile & noexcept>);
+static_assert(regular<int (S::*)() volatile&&>);
+static_assert(regular<int (S::*)() volatile && noexcept>);
+static_assert(regular<int (S::*)() const volatile>);
+static_assert(regular<int (S::*)() const volatile noexcept>);
+static_assert(regular<int (S::*)() const volatile&>);
+static_assert(regular<int (S::*)() const volatile & noexcept>);
+static_assert(regular<int (S::*)() const volatile&&>);
+static_assert(regular<int (S::*)() const volatile && noexcept>);
+
+union U {};
+static_assert(!regular<U>);
+static_assert(regular<int U::*>);
+static_assert(regular<int (U::*)()>);
+static_assert(regular<int (U::*)() noexcept>);
+static_assert(regular<int (U::*)() &>);
+static_assert(regular<int (U::*)() & noexcept>);
+static_assert(regular<int (U::*)() &&>);
+static_assert(regular<int (U::*)() && noexcept>);
+static_assert(regular<int (U::*)() const>);
+static_assert(regular<int (U::*)() const noexcept>);
+static_assert(regular<int (U::*)() const&>);
+static_assert(regular<int (U::*)() const & noexcept>);
+static_assert(regular<int (U::*)() const&&>);
+static_assert(regular<int (U::*)() const && noexcept>);
+static_assert(regular<int (U::*)() volatile>);
+static_assert(regular<int (U::*)() volatile noexcept>);
+static_assert(regular<int (U::*)() volatile&>);
+static_assert(regular<int (U::*)() volatile & noexcept>);
+static_assert(regular<int (U::*)() volatile&&>);
+static_assert(regular<int (U::*)() volatile && noexcept>);
+static_assert(regular<int (U::*)() const volatile>);
+static_assert(regular<int (U::*)() const volatile noexcept>);
+static_assert(regular<int (U::*)() const volatile&>);
+static_assert(regular<int (U::*)() const volatile & noexcept>);
+static_assert(regular<int (U::*)() const volatile&&>);
+static_assert(regular<int (U::*)() const volatile && noexcept>);
+
+static_assert(!regular<has_volatile_member>);
+static_assert(!regular<has_array_member>);
+
+// Not objects
+static_assert(!regular<void>);
+static_assert(!regular<int&>);
+static_assert(!regular<int const&>);
+static_assert(!regular<int volatile&>);
+static_assert(!regular<int const volatile&>);
+static_assert(!regular<int&&>);
+static_assert(!regular<int const&&>);
+static_assert(!regular<int volatile&&>);
+static_assert(!regular<int const volatile&&>);
+static_assert(!regular<int()>);
+static_assert(!regular<int (&)()>);
+static_assert(!regular<int[5]>);
+
+// not copyable
+static_assert(!regular<int const>);
+static_assert(!regular<int const volatile>);
+static_assert(!regular<volatile_copy_assignment volatile>);
+static_assert(!regular<no_copy_constructor>);
+static_assert(!regular<no_copy_assignment>);
+static_assert(!regular<no_copy_assignment_mutable>);
+static_assert(!regular<derived_from_noncopyable>);
+static_assert(!regular<has_noncopyable>);
+static_assert(!regular<has_const_member>);
+static_assert(!regular<has_cv_member>);
+static_assert(!regular<has_lvalue_reference_member>);
+static_assert(!regular<has_rvalue_reference_member>);
+static_assert(!regular<has_function_ref_member>);
+static_assert(!regular<deleted_assignment_from_const_rvalue>);
+
+// not default_initializable
+static_assert(!regular<no_copy_constructor>);
+static_assert(!regular<no_copy_assignment>);
+static_assert(cuda::std::is_copy_assignable_v<no_copy_assignment_mutable> &&
+              !regular<no_copy_assignment_mutable>);
+static_assert(!regular<derived_from_noncopyable>);
+static_assert(!regular<has_noncopyable>);
+
+static_assert(!regular<derived_from_non_default_initializable>);
+static_assert(!regular<has_non_default_initializable>);
+
+// not equality_comparable
+static_assert(!regular<const_copy_assignment const>);
+static_assert(!regular<cv_copy_assignment const volatile>);
+
+struct is_equality_comparable {
+  bool operator==(is_equality_comparable const&) const { return true; }
+  bool operator!=(is_equality_comparable const&) const { return false; }
+};
+static_assert(regular<is_equality_comparable>);
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/std/concepts/concepts.object/semiregular.compile.pass.cpp b/.upstream-tests/test/std/concepts/concepts.object/semiregular.compile.pass.cpp
new file mode 100644
index 0000000000..b44cede052
--- /dev/null
+++ b/.upstream-tests/test/std/concepts/concepts.object/semiregular.compile.pass.cpp
@@ -0,0 +1,108 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11
+
+// template<class T>
+// concept semiregular = see below;
+
+#include <cuda/std/concepts>
+
+#include "type_classification/semiregular.h"
+
+using cuda::std::semiregular;
+
+static_assert(semiregular<int>);
+static_assert(semiregular<int volatile>);
+static_assert(semiregular<int*>);
+static_assert(semiregular<int const*>);
+static_assert(semiregular<int volatile*>);
+static_assert(semiregular<int volatile const*>);
+static_assert(semiregular<int (*)()>);
+
+struct S {};
+static_assert(semiregular<S>);
+static_assert(semiregular<int S::*>);
+static_assert(semiregular<int (S::*)()>);
+static_assert(semiregular<int (S::*)() noexcept>);
+static_assert(semiregular<int (S::*)() &>);
+static_assert(semiregular<int (S::*)() & noexcept>);
+static_assert(semiregular<int (S::*)() &&>);
+static_assert(semiregular<int (S::*)() && noexcept>);
+static_assert(semiregular<int (S::*)() const>);
+static_assert(semiregular<int (S::*)() const noexcept>);
+static_assert(semiregular<int (S::*)() const&>);
+static_assert(semiregular<int (S::*)() const & noexcept>);
+static_assert(semiregular<int (S::*)() const&&>);
+static_assert(semiregular<int (S::*)() const && noexcept>);
+static_assert(semiregular<int (S::*)() volatile>);
+static_assert(semiregular<int (S::*)() volatile noexcept>);
+static_assert(semiregular<int (S::*)() volatile&>);
+static_assert(semiregular<int (S::*)() volatile & noexcept>);
+static_assert(semiregular<int (S::*)() volatile&&>);
+static_assert(semiregular<int (S::*)() volatile && noexcept>);
+static_assert(semiregular<int (S::*)() const volatile>);
+static_assert(semiregular<int (S::*)() const volatile noexcept>);
+static_assert(semiregular<int (S::*)() const volatile&>);
+static_assert(semiregular<int (S::*)() const volatile & noexcept>);
+static_assert(semiregular<int (S::*)() const volatile&&>);
+static_assert(semiregular<int (S::*)() const volatile && noexcept>);
+
+static_assert(semiregular<has_volatile_member>);
+static_assert(semiregular<has_array_member>);
+
+// Not objects
+static_assert(!semiregular<void>);
+static_assert(!semiregular<int&>);
+static_assert(!semiregular<int const&>);
+static_assert(!semiregular<int volatile&>);
+static_assert(!semiregular<int const volatile&>);
+static_assert(!semiregular<int&&>);
+static_assert(!semiregular<int const&&>);
+static_assert(!semiregular<int volatile&&>);
+static_assert(!semiregular<int const volatile&&>);
+static_assert(!semiregular<int()>);
+static_assert(!semiregular<int (&)()>);
+static_assert(!semiregular<int[5]>);
+
+// Not copyable
+static_assert(!semiregular<int const>);
+static_assert(!semiregular<int const volatile>);
+static_assert(semiregular<const_copy_assignment const>);
+static_assert(!semiregular<volatile_copy_assignment volatile>);
+static_assert(semiregular<cv_copy_assignment const volatile>);
+static_assert(!semiregular<no_copy_constructor>);
+static_assert(!semiregular<no_copy_assignment>);
+static_assert(!semiregular<no_copy_assignment_mutable>);
+static_assert(!semiregular<derived_from_noncopyable>);
+static_assert(!semiregular<has_noncopyable>);
+static_assert(!semiregular<has_const_member>);
+static_assert(!semiregular<has_cv_member>);
+static_assert(!semiregular<has_lvalue_reference_member>);
+static_assert(!semiregular<has_rvalue_reference_member>);
+static_assert(!semiregular<has_function_ref_member>);
+static_assert(!semiregular<deleted_assignment_from_const_rvalue>);
+
+// Not default_initialzable
+static_assert(!semiregular<no_copy_constructor>);
+static_assert(!semiregular<no_copy_assignment>);
+static_assert(cuda::std::is_copy_assignable_v<no_copy_assignment_mutable>);
+static_assert(!semiregular<no_copy_assignment_mutable>);
+static_assert(!semiregular<derived_from_noncopyable>);
+static_assert(!semiregular<has_noncopyable>);
+
+static_assert(!semiregular<no_default_ctor>);
+static_assert(!semiregular<derived_from_non_default_initializable>);
+static_assert(!semiregular<has_non_default_initializable>);
+
+static_assert(!semiregular<deleted_default_ctor>);
+static_assert(!semiregular<derived_from_deleted_default_ctor>);
+static_assert(!semiregular<has_deleted_default_ctor>);
+
+int main(int, char**) { return 0; }
diff --git a/.upstream-tests/test/support/compare_types.h b/.upstream-tests/test/support/compare_types.h
new file mode 100644
index 0000000000..606201f4b6
--- /dev/null
+++ b/.upstream-tests/test/support/compare_types.h
@@ -0,0 +1,399 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TEST_SUPPORT_COMPARE_TYPES_H
+#define TEST_SUPPORT_COMPARE_TYPES_H
+
+#include <cuda/std/concepts>
+#include <cuda/std/type_traits>
+
+// `noexcept` specifiers deliberately imperfect since not all programmers bother to put the
+// specifiers on their overloads.
+
+struct equality_comparable_with_ec1;
+struct no_neq;
+
+struct explicit_operators {
+  friend bool operator==(explicit_operators, explicit_operators) noexcept;
+  friend bool operator!=(explicit_operators, explicit_operators) noexcept;
+  friend bool operator<(explicit_operators, explicit_operators) noexcept;
+  friend bool operator>(explicit_operators, explicit_operators) noexcept;
+  friend bool operator<=(explicit_operators, explicit_operators) noexcept;
+  friend bool operator>=(explicit_operators, explicit_operators) noexcept;
+
+  friend bool operator==(explicit_operators const&, equality_comparable_with_ec1 const&) noexcept;
+  friend bool operator==(equality_comparable_with_ec1 const&, explicit_operators const&) noexcept;
+  friend bool operator!=(explicit_operators const&, equality_comparable_with_ec1 const&) noexcept;
+  friend bool operator!=(equality_comparable_with_ec1 const&, explicit_operators const&) noexcept;
+};
+
+struct different_return_types {
+  bool operator==(different_return_types) const noexcept;
+  char operator!=(different_return_types) const noexcept;
+  short operator<(different_return_types) const noexcept;
+  int operator>(different_return_types) const noexcept;
+  long operator<=(different_return_types) const noexcept;
+  long long operator>=(different_return_types) const noexcept;
+
+  friend signed char operator==(explicit_operators, different_return_types);
+  friend unsigned char operator==(different_return_types, explicit_operators);
+  friend float operator!=(explicit_operators, different_return_types);
+  friend double operator!=(different_return_types, explicit_operators);
+
+  operator explicit_operators() const;
+};
+
+struct boolean {
+  operator bool() const noexcept;
+};
+
+struct one_member_one_friend {
+  friend boolean operator==(one_member_one_friend, one_member_one_friend) noexcept;
+  boolean operator!=(one_member_one_friend) const noexcept;
+
+  operator explicit_operators() const noexcept;
+  operator different_return_types() const noexcept;
+};
+
+struct equality_comparable_with_ec1 {
+  bool operator==(equality_comparable_with_ec1) const noexcept;
+  bool operator!=(equality_comparable_with_ec1) const noexcept;
+  operator explicit_operators() const noexcept;
+};
+
+struct no_eq {
+  friend bool operator==(no_eq, no_eq) = delete;
+  friend bool operator!=(no_eq, no_eq) noexcept;
+  friend bool operator<(no_eq, no_eq) noexcept;
+  friend bool operator>(no_eq, no_eq) noexcept;
+  friend bool operator>=(no_eq, no_eq) noexcept;
+  friend bool operator<=(no_eq, no_eq) noexcept;
+};
+
+struct no_neq {
+  friend bool operator==(no_neq, no_neq) noexcept;
+  friend bool operator!=(no_neq, no_neq) = delete;
+  friend bool operator<(no_eq, no_eq) noexcept;
+  friend bool operator>(no_eq, no_eq) noexcept;
+  friend bool operator>=(no_eq, no_eq) noexcept;
+  friend bool operator<=(no_eq, no_eq) noexcept;
+};
+
+struct no_lt {
+  friend bool operator==(no_lt, no_lt) noexcept;
+  friend bool operator!=(no_lt, no_lt) noexcept;
+  friend bool operator<(no_lt, no_lt) = delete;
+  friend bool operator>(no_lt, no_lt) noexcept;
+  friend bool operator>=(no_lt, no_lt) noexcept;
+  friend bool operator<=(no_lt, no_lt) noexcept;
+};
+
+struct no_gt {
+  friend bool operator==(no_gt, no_gt) noexcept;
+  friend bool operator!=(no_gt, no_gt) noexcept;
+  friend bool operator<(no_gt, no_gt) noexcept;
+  friend bool operator>(no_gt, no_gt) = delete;
+  friend bool operator>=(no_gt, no_gt) noexcept;
+  friend bool operator<=(no_gt, no_gt) noexcept;
+};
+
+struct no_le {
+  friend bool operator==(no_le, no_le) noexcept;
+  friend bool operator!=(no_le, no_le) noexcept;
+  friend bool operator<(no_le, no_le) noexcept;
+  friend bool operator>(no_le, no_le) noexcept;
+  friend bool operator>=(no_le, no_le) = delete;
+  friend bool operator<=(no_le, no_le) noexcept;
+};
+
+struct no_ge {
+  friend bool operator==(no_ge, no_ge) noexcept;
+  friend bool operator!=(no_ge, no_ge) noexcept;
+  friend bool operator<(no_ge, no_ge) noexcept;
+  friend bool operator>(no_ge, no_ge) noexcept;
+  friend bool operator>=(no_ge, no_ge) noexcept;
+  friend bool operator<=(no_ge, no_ge) = delete;
+};
+
+struct wrong_return_type_eq {
+  void operator==(wrong_return_type_eq) const noexcept;
+  bool operator!=(wrong_return_type_eq) const noexcept;
+  bool operator<(wrong_return_type_eq) const noexcept;
+  bool operator>(wrong_return_type_eq) const noexcept;
+  bool operator>=(wrong_return_type_eq) const noexcept;
+  bool operator<=(wrong_return_type_eq) const noexcept;
+};
+
+struct wrong_return_type_ne {
+  bool operator==(wrong_return_type_ne) const noexcept;
+  void operator!=(wrong_return_type_ne) const noexcept;
+  bool operator<(wrong_return_type_ne) const noexcept;
+  bool operator>(wrong_return_type_ne) const noexcept;
+  bool operator>=(wrong_return_type_ne) const noexcept;
+  bool operator<=(wrong_return_type_ne) const noexcept;
+};
+
+struct wrong_return_type_lt {
+  bool operator==(wrong_return_type_lt) const noexcept;
+  bool operator!=(wrong_return_type_lt) const noexcept;
+  void operator<(wrong_return_type_lt) const noexcept;
+  bool operator>(wrong_return_type_lt) const noexcept;
+  bool operator>=(wrong_return_type_lt) const noexcept;
+  bool operator<=(wrong_return_type_lt) const noexcept;
+};
+
+struct wrong_return_type_gt {
+  bool operator==(wrong_return_type_gt) const noexcept;
+  bool operator!=(wrong_return_type_gt) const noexcept;
+  bool operator<(wrong_return_type_gt) const noexcept;
+  void operator>(wrong_return_type_gt) const noexcept;
+  bool operator>=(wrong_return_type_gt) const noexcept;
+  bool operator<=(wrong_return_type_gt) const noexcept;
+};
+
+struct wrong_return_type_le {
+  bool operator==(wrong_return_type_le) const noexcept;
+  bool operator!=(wrong_return_type_le) const noexcept;
+  bool operator<(wrong_return_type_le) const noexcept;
+  bool operator>(wrong_return_type_le) const noexcept;
+  void operator>=(wrong_return_type_le) const noexcept;
+  bool operator<=(wrong_return_type_le) const noexcept;
+};
+
+struct wrong_return_type_ge {
+  bool operator==(wrong_return_type_ge) const noexcept;
+  bool operator!=(wrong_return_type_ge) const noexcept;
+  bool operator<(wrong_return_type_ge) const noexcept;
+  bool operator>(wrong_return_type_ge) const noexcept;
+  bool operator>=(wrong_return_type_ge) const noexcept;
+  void operator<=(wrong_return_type_ge) const noexcept;
+};
+
+struct wrong_return_type {
+  void operator==(wrong_return_type) const noexcept;
+  void operator!=(wrong_return_type) const noexcept;
+  void operator<(wrong_return_type) const noexcept;
+  void operator>(wrong_return_type) const noexcept;
+  void operator>=(wrong_return_type) const noexcept;
+  void operator<=(wrong_return_type_ge) const noexcept;
+};
+
+struct explicit_bool {
+  explicit operator bool() const noexcept;
+};
+
+struct totally_ordered_with_others {};
+
+struct eq_returns_explicit_bool {
+  friend explicit_bool operator==(eq_returns_explicit_bool, eq_returns_explicit_bool);
+  friend bool operator!=(eq_returns_explicit_bool, eq_returns_explicit_bool);
+  friend bool operator<(eq_returns_explicit_bool, eq_returns_explicit_bool);
+  friend bool operator>(eq_returns_explicit_bool, eq_returns_explicit_bool);
+  friend bool operator<=(eq_returns_explicit_bool, eq_returns_explicit_bool);
+  friend bool operator>=(eq_returns_explicit_bool, eq_returns_explicit_bool);
+
+  operator totally_ordered_with_others() const;
+
+  friend explicit_bool operator==(eq_returns_explicit_bool, totally_ordered_with_others);
+  friend explicit_bool operator==(totally_ordered_with_others, eq_returns_explicit_bool);
+  friend bool operator!=(eq_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(totally_ordered_with_others, eq_returns_explicit_bool);
+  friend bool operator<(eq_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<(totally_ordered_with_others, eq_returns_explicit_bool);
+  friend bool operator>(eq_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>(totally_ordered_with_others, eq_returns_explicit_bool);
+  friend bool operator<=(eq_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<=(totally_ordered_with_others, eq_returns_explicit_bool);
+  friend bool operator>=(eq_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>=(totally_ordered_with_others, eq_returns_explicit_bool);
+};
+
+struct ne_returns_explicit_bool {
+  friend bool operator==(ne_returns_explicit_bool, ne_returns_explicit_bool);
+  friend explicit_bool operator!=(ne_returns_explicit_bool, ne_returns_explicit_bool);
+  friend bool operator<(ne_returns_explicit_bool, ne_returns_explicit_bool);
+  friend bool operator>(ne_returns_explicit_bool, ne_returns_explicit_bool);
+  friend bool operator<=(ne_returns_explicit_bool, ne_returns_explicit_bool);
+  friend bool operator>=(ne_returns_explicit_bool, ne_returns_explicit_bool);
+
+  operator totally_ordered_with_others() const;
+
+  friend bool operator==(ne_returns_explicit_bool, totally_ordered_with_others);
+  friend explicit_bool operator!=(ne_returns_explicit_bool, totally_ordered_with_others);
+  friend explicit_bool operator!=(totally_ordered_with_others, ne_returns_explicit_bool);
+  friend bool operator<(ne_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<(totally_ordered_with_others, ne_returns_explicit_bool);
+  friend bool operator>(ne_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>(totally_ordered_with_others, ne_returns_explicit_bool);
+  friend bool operator<=(ne_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<=(totally_ordered_with_others, ne_returns_explicit_bool);
+  friend bool operator>=(ne_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>=(totally_ordered_with_others, ne_returns_explicit_bool);
+};
+
+struct lt_returns_explicit_bool {
+  friend bool operator==(lt_returns_explicit_bool, lt_returns_explicit_bool);
+  friend bool operator!=(lt_returns_explicit_bool, lt_returns_explicit_bool);
+  friend explicit_bool operator<(lt_returns_explicit_bool, lt_returns_explicit_bool);
+  friend bool operator>(lt_returns_explicit_bool, lt_returns_explicit_bool);
+  friend bool operator<=(lt_returns_explicit_bool, lt_returns_explicit_bool);
+  friend bool operator>=(lt_returns_explicit_bool, lt_returns_explicit_bool);
+
+  operator totally_ordered_with_others() const;
+
+  friend bool operator==(lt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(lt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(totally_ordered_with_others, lt_returns_explicit_bool);
+  friend explicit_bool operator<(lt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<(totally_ordered_with_others, lt_returns_explicit_bool);
+  friend bool operator>(lt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>(totally_ordered_with_others, lt_returns_explicit_bool);
+  friend bool operator<=(lt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<=(totally_ordered_with_others, lt_returns_explicit_bool);
+  friend bool operator>=(lt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>=(totally_ordered_with_others, lt_returns_explicit_bool);
+};
+
+struct gt_returns_explicit_bool {
+  friend bool operator==(gt_returns_explicit_bool, gt_returns_explicit_bool);
+  friend bool operator!=(gt_returns_explicit_bool, gt_returns_explicit_bool);
+  friend bool operator<(gt_returns_explicit_bool, gt_returns_explicit_bool);
+  friend explicit_bool operator>(gt_returns_explicit_bool, gt_returns_explicit_bool);
+  friend bool operator<=(gt_returns_explicit_bool, gt_returns_explicit_bool);
+  friend bool operator>=(gt_returns_explicit_bool, gt_returns_explicit_bool);
+
+  operator totally_ordered_with_others() const;
+
+  friend bool operator==(gt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(gt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(totally_ordered_with_others, gt_returns_explicit_bool);
+  friend bool operator<(gt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<(totally_ordered_with_others, gt_returns_explicit_bool);
+  friend explicit_bool operator>(gt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>(totally_ordered_with_others, gt_returns_explicit_bool);
+  friend bool operator<=(gt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<=(totally_ordered_with_others, gt_returns_explicit_bool);
+  friend bool operator>=(gt_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>=(totally_ordered_with_others, gt_returns_explicit_bool);
+};
+
+struct le_returns_explicit_bool {
+  friend bool operator==(le_returns_explicit_bool, le_returns_explicit_bool);
+  friend bool operator!=(le_returns_explicit_bool, le_returns_explicit_bool);
+  friend bool operator<(le_returns_explicit_bool, le_returns_explicit_bool);
+  friend bool operator>(le_returns_explicit_bool, le_returns_explicit_bool);
+  friend explicit_bool operator<=(le_returns_explicit_bool, le_returns_explicit_bool);
+  friend bool operator>=(le_returns_explicit_bool, le_returns_explicit_bool);
+
+  operator totally_ordered_with_others() const;
+
+  friend bool operator==(le_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(le_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(totally_ordered_with_others, le_returns_explicit_bool);
+  friend bool operator<(le_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<(totally_ordered_with_others, le_returns_explicit_bool);
+  friend bool operator>(le_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>(totally_ordered_with_others, le_returns_explicit_bool);
+  friend bool operator<=(le_returns_explicit_bool, totally_ordered_with_others);
+  friend explicit_bool operator<=(totally_ordered_with_others, le_returns_explicit_bool);
+  friend bool operator>=(le_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>=(totally_ordered_with_others, le_returns_explicit_bool);
+};
+
+struct ge_returns_explicit_bool {
+  friend bool operator==(ge_returns_explicit_bool, ge_returns_explicit_bool);
+  friend bool operator!=(ge_returns_explicit_bool, ge_returns_explicit_bool);
+  friend bool operator<(ge_returns_explicit_bool, ge_returns_explicit_bool);
+  friend bool operator>(ge_returns_explicit_bool, ge_returns_explicit_bool);
+  friend bool operator<=(ge_returns_explicit_bool, ge_returns_explicit_bool);
+  friend explicit_bool operator>=(ge_returns_explicit_bool, ge_returns_explicit_bool);
+
+  operator totally_ordered_with_others() const;
+
+  friend bool operator==(ge_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(ge_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator!=(totally_ordered_with_others, ge_returns_explicit_bool);
+  friend bool operator<(ge_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<(totally_ordered_with_others, ge_returns_explicit_bool);
+  friend bool operator>(ge_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator>(totally_ordered_with_others, ge_returns_explicit_bool);
+  friend bool operator<=(ge_returns_explicit_bool, totally_ordered_with_others);
+  friend bool operator<=(totally_ordered_with_others, ge_returns_explicit_bool);
+  friend bool operator>=(ge_returns_explicit_bool, totally_ordered_with_others);
+  friend explicit_bool operator>=(totally_ordered_with_others, ge_returns_explicit_bool);
+};
+
+struct returns_true_type {
+  friend std::true_type operator==(returns_true_type, returns_true_type);
+  friend std::true_type operator!=(returns_true_type, returns_true_type);
+  friend std::true_type operator<(returns_true_type, returns_true_type);
+  friend std::true_type operator>(returns_true_type, returns_true_type);
+  friend std::true_type operator<=(returns_true_type, returns_true_type);
+  friend std::true_type operator>=(returns_true_type, returns_true_type);
+
+  operator totally_ordered_with_others() const;
+
+  friend std::true_type operator==(returns_true_type, totally_ordered_with_others);
+  friend std::true_type operator==(totally_ordered_with_others, returns_true_type);
+  friend std::true_type operator!=(returns_true_type, totally_ordered_with_others);
+  friend std::true_type operator!=(totally_ordered_with_others, returns_true_type);
+  friend std::true_type operator<(returns_true_type, totally_ordered_with_others);
+  friend std::true_type operator<(totally_ordered_with_others, returns_true_type);
+  friend std::true_type operator>(returns_true_type, totally_ordered_with_others);
+  friend std::true_type operator>(totally_ordered_with_others, returns_true_type);
+  friend std::true_type operator<=(returns_true_type, totally_ordered_with_others);
+  friend std::true_type operator<=(totally_ordered_with_others, returns_true_type);
+  friend std::true_type operator>=(returns_true_type, totally_ordered_with_others);
+  friend std::true_type operator>=(totally_ordered_with_others, returns_true_type);
+};
+
+struct returns_int_ptr {
+  friend int* operator==(returns_int_ptr, returns_int_ptr);
+  friend int* operator!=(returns_int_ptr, returns_int_ptr);
+  friend int* operator<(returns_int_ptr, returns_int_ptr);
+  friend int* operator>(returns_int_ptr, returns_int_ptr);
+  friend int* operator<=(returns_int_ptr, returns_int_ptr);
+  friend int* operator>=(returns_int_ptr, returns_int_ptr);
+
+  operator totally_ordered_with_others() const;
+
+  friend int* operator==(returns_int_ptr, totally_ordered_with_others);
+  friend int* operator==(totally_ordered_with_others, returns_int_ptr);
+  friend int* operator!=(returns_int_ptr, totally_ordered_with_others);
+  friend int* operator!=(totally_ordered_with_others, returns_int_ptr);
+  friend int* operator<(returns_int_ptr, totally_ordered_with_others);
+  friend int* operator<(totally_ordered_with_others, returns_int_ptr);
+  friend int* operator>(returns_int_ptr, totally_ordered_with_others);
+  friend int* operator>(totally_ordered_with_others, returns_int_ptr);
+  friend int* operator<=(returns_int_ptr, totally_ordered_with_others);
+  friend int* operator<=(totally_ordered_with_others, returns_int_ptr);
+  friend int* operator>=(returns_int_ptr, totally_ordered_with_others);
+  friend int* operator>=(totally_ordered_with_others, returns_int_ptr);
+};
+
+struct ForwardingTestObject {
+  constexpr bool operator<(ForwardingTestObject&&) && { return true; }
+  constexpr bool operator<(const ForwardingTestObject&) const& { return false; }
+
+  constexpr bool operator==(ForwardingTestObject&&) && { return true; }
+  constexpr bool operator==(const ForwardingTestObject&) const& { return false; }
+
+  constexpr bool operator!=(ForwardingTestObject&&) && { return true; }
+  constexpr bool operator!=(const ForwardingTestObject&) const& { return false; }
+
+  constexpr bool operator<=(ForwardingTestObject&&) && { return true; }
+  constexpr bool operator<=(const ForwardingTestObject&) const& { return false; }
+
+  constexpr bool operator>(ForwardingTestObject&&) && { return true; }
+  constexpr bool operator>(const ForwardingTestObject&) const& { return false; }
+
+  constexpr bool operator>=(ForwardingTestObject&&) && { return true; }
+  constexpr bool operator>=(const ForwardingTestObject&) const& { return false; }
+};
+
+#endif // TEST_SUPPORT_COMPARE_TYPES_H
diff --git a/.upstream-tests/test/support/type_classification/copyable.h b/.upstream-tests/test/support/type_classification/copyable.h
new file mode 100644
index 0000000000..611a5d2630
--- /dev/null
+++ b/.upstream-tests/test/support/type_classification/copyable.h
@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TEST_SUPPORT_TYPE_CLASSIFICATION_COPYABLE_H
+#define TEST_SUPPORT_TYPE_CLASSIFICATION_COPYABLE_H
+
+#include <memory>
+
+#include "movable.h"
+
+struct no_copy_constructor {
+  no_copy_constructor() = default;
+
+  no_copy_constructor(no_copy_constructor const&) = delete;
+  no_copy_constructor(no_copy_constructor&&) = default;
+};
+
+struct no_copy_assignment {
+  no_copy_assignment() = default;
+
+  no_copy_assignment& operator=(no_copy_assignment const&) = delete;
+  no_copy_assignment& operator=(no_copy_assignment&&) = default;
+};
+
+struct no_copy_assignment_mutable {
+  no_copy_assignment_mutable() = default;
+
+  no_copy_assignment_mutable&
+  operator=(no_copy_assignment_mutable const&) = default;
+  no_copy_assignment_mutable& operator=(no_copy_assignment_mutable&) = delete;
+  no_copy_assignment_mutable& operator=(no_copy_assignment_mutable&&) = default;
+};
+
+struct derived_from_noncopyable : std::unique_ptr<int> {};
+
+struct has_noncopyable {
+  std::unique_ptr<int> x;
+};
+
+struct const_copy_assignment {
+  const_copy_assignment() = default;
+
+  const_copy_assignment(const_copy_assignment const&);
+  const_copy_assignment(const_copy_assignment&&);
+
+  const_copy_assignment& operator=(const_copy_assignment&&);
+  const_copy_assignment const& operator=(const_copy_assignment const&) const;
+};
+
+struct volatile_copy_assignment {
+  volatile_copy_assignment() = default;
+
+  volatile_copy_assignment(volatile_copy_assignment volatile&);
+  volatile_copy_assignment(volatile_copy_assignment volatile&&);
+
+  volatile_copy_assignment& operator=(volatile_copy_assignment&&);
+  volatile_copy_assignment volatile&
+  operator=(volatile_copy_assignment const&) volatile;
+};
+
+struct cv_copy_assignment {
+  cv_copy_assignment() = default;
+
+  cv_copy_assignment(cv_copy_assignment const volatile&);
+  cv_copy_assignment(cv_copy_assignment const volatile&&);
+
+  cv_copy_assignment const volatile&
+  operator=(cv_copy_assignment const volatile&) const volatile;
+  cv_copy_assignment const volatile&
+  operator=(cv_copy_assignment const volatile&&) const volatile;
+};
+
+#endif // TEST_SUPPORT_TYPE_CLASSIFICATION_COPYABLE_H
diff --git a/.upstream-tests/test/support/type_classification/movable.h b/.upstream-tests/test/support/type_classification/movable.h
new file mode 100644
index 0000000000..4c841c3a82
--- /dev/null
+++ b/.upstream-tests/test/support/type_classification/movable.h
@@ -0,0 +1,159 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TEST_SUPPORT_TYPE_CLASSIFICATION_MOVABLE_H
+#define TEST_SUPPORT_TYPE_CLASSIFICATION_MOVABLE_H
+
+struct has_const_member {
+  int const x;
+};
+
+struct has_volatile_member {
+  int volatile x;
+};
+
+struct has_cv_member {
+  int const volatile x;
+};
+
+struct has_lvalue_reference_member {
+  int& x;
+};
+
+struct has_rvalue_reference_member {
+  int&& x;
+};
+
+struct has_array_member {
+  int x[5];
+};
+
+struct has_function_ref_member {
+  int (&f)();
+};
+
+struct cpp03_friendly {
+  cpp03_friendly(cpp03_friendly const&);
+  cpp03_friendly& operator=(cpp03_friendly const&);
+};
+
+struct const_move_ctor {
+  const_move_ctor(const_move_ctor const&&);
+  const_move_ctor& operator=(const_move_ctor&&);
+};
+
+struct volatile_move_ctor {
+  volatile_move_ctor(volatile_move_ctor volatile&&);
+  volatile_move_ctor& operator=(volatile_move_ctor&&);
+};
+
+struct cv_move_ctor {
+  cv_move_ctor(cv_move_ctor const volatile&&);
+  cv_move_ctor& operator=(cv_move_ctor&&);
+};
+
+struct multi_param_move_ctor {
+  multi_param_move_ctor(multi_param_move_ctor&&, int = 0);
+  multi_param_move_ctor& operator=(multi_param_move_ctor&&);
+};
+
+struct not_quite_multi_param_move_ctor {
+  not_quite_multi_param_move_ctor(not_quite_multi_param_move_ctor&&, int);
+  not_quite_multi_param_move_ctor& operator=(not_quite_multi_param_move_ctor&&);
+};
+
+struct copy_with_mutable_parameter {
+  copy_with_mutable_parameter(copy_with_mutable_parameter&);
+  copy_with_mutable_parameter&
+  operator=(copy_with_mutable_parameter&);
+};
+
+struct const_move_assignment {
+  const_move_assignment& operator=(const_move_assignment&&) const;
+};
+
+struct volatile_move_assignment {
+  const_move_assignment& operator=(const_move_assignment&&) volatile;
+};
+
+struct cv_move_assignment {
+  cv_move_assignment& operator=(cv_move_assignment&&) const volatile;
+};
+
+struct const_move_assign_and_traditional_move_assign {
+  const_move_assign_and_traditional_move_assign&
+  operator=(const_move_assign_and_traditional_move_assign&&);
+  const_move_assign_and_traditional_move_assign&
+  operator=(const_move_assign_and_traditional_move_assign&&) const;
+};
+
+struct volatile_move_assign_and_traditional_move_assign {
+  volatile_move_assign_and_traditional_move_assign&
+  operator=(volatile_move_assign_and_traditional_move_assign&&);
+  volatile_move_assign_and_traditional_move_assign&
+  operator=(volatile_move_assign_and_traditional_move_assign&&) volatile;
+};
+
+struct cv_move_assign_and_traditional_move_assign {
+  cv_move_assign_and_traditional_move_assign&
+  operator=(cv_move_assign_and_traditional_move_assign&&);
+  cv_move_assign_and_traditional_move_assign&
+  operator=(cv_move_assign_and_traditional_move_assign&&) const volatile;
+};
+
+struct const_move_assign_and_default_ops {
+  const_move_assign_and_default_ops(const_move_assign_and_default_ops const&) =
+      default;
+  const_move_assign_and_default_ops(const_move_assign_and_default_ops&&) =
+      default;
+  const_move_assign_and_default_ops&
+  operator=(const_move_assign_and_default_ops const&) = default;
+  const_move_assign_and_default_ops&
+  operator=(const_move_assign_and_default_ops&&) = default;
+  const_move_assign_and_default_ops&
+  operator=(const_move_assign_and_default_ops&&) const;
+};
+
+struct volatile_move_assign_and_default_ops {
+  volatile_move_assign_and_default_ops(
+      volatile_move_assign_and_default_ops const&) = default;
+  volatile_move_assign_and_default_ops(volatile_move_assign_and_default_ops&&) =
+      default;
+  volatile_move_assign_and_default_ops&
+  operator=(volatile_move_assign_and_default_ops const&) = default;
+  volatile_move_assign_and_default_ops&
+  operator=(volatile_move_assign_and_default_ops&&) = default;
+  volatile_move_assign_and_default_ops&
+  operator=(volatile_move_assign_and_default_ops&&) volatile;
+};
+
+struct cv_move_assign_and_default_ops {
+  cv_move_assign_and_default_ops(cv_move_assign_and_default_ops const&) =
+      default;
+  cv_move_assign_and_default_ops(cv_move_assign_and_default_ops&&) = default;
+  cv_move_assign_and_default_ops&
+  operator=(cv_move_assign_and_default_ops const&) = default;
+  cv_move_assign_and_default_ops&
+  operator=(cv_move_assign_and_default_ops&&) = default;
+  cv_move_assign_and_default_ops&
+  operator=(cv_move_assign_and_default_ops&&) const volatile;
+};
+
+struct deleted_assignment_from_const_rvalue {
+  deleted_assignment_from_const_rvalue(
+      deleted_assignment_from_const_rvalue const&);
+  deleted_assignment_from_const_rvalue(deleted_assignment_from_const_rvalue&&);
+  deleted_assignment_from_const_rvalue&
+  operator=(const deleted_assignment_from_const_rvalue&);
+  deleted_assignment_from_const_rvalue&
+  operator=(deleted_assignment_from_const_rvalue&&);
+  deleted_assignment_from_const_rvalue&
+  operator=(const deleted_assignment_from_const_rvalue&&) = delete;
+};
+
+#endif // TEST_SUPPORT_TYPE_CLASSIFICATION_MOVABLE_H
diff --git a/.upstream-tests/test/support/type_classification/moveconstructible.h b/.upstream-tests/test/support/type_classification/moveconstructible.h
new file mode 100644
index 0000000000..82c4a7fc39
--- /dev/null
+++ b/.upstream-tests/test/support/type_classification/moveconstructible.h
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TEST_SUPPORT_TYPE_CLASSIFICATION_MOVECONSTRUCTIBLE_H
+#define TEST_SUPPORT_TYPE_CLASSIFICATION_MOVECONSTRUCTIBLE_H
+
+struct HasDefaultOps {};
+
+struct CustomMoveCtor {
+  CustomMoveCtor(CustomMoveCtor&&) noexcept;
+};
+
+struct MoveOnly {
+  MoveOnly(MoveOnly&&) noexcept = default;
+  MoveOnly& operator=(MoveOnly&&) noexcept = default;
+  MoveOnly(const MoveOnly&) = delete;
+  MoveOnly& operator=(const MoveOnly&) = default;
+};
+
+struct CustomMoveAssign {
+  CustomMoveAssign(CustomMoveAssign&&) noexcept;
+  CustomMoveAssign& operator=(CustomMoveAssign&&) noexcept;
+};
+
+struct DeletedMoveCtor {
+  DeletedMoveCtor(DeletedMoveCtor&&) = delete;
+  DeletedMoveCtor& operator=(DeletedMoveCtor&&) = default;
+};
+
+struct ImplicitlyDeletedMoveCtor {
+  DeletedMoveCtor X;
+};
+
+struct DeletedMoveAssign {
+  DeletedMoveAssign& operator=(DeletedMoveAssign&&) = delete;
+};
+
+struct ImplicitlyDeletedMoveAssign {
+  DeletedMoveAssign X;
+};
+
+class MemberLvalueReference {
+public:
+  MemberLvalueReference(int&);
+
+private:
+  int& X;
+};
+
+class MemberRvalueReference {
+public:
+  MemberRvalueReference(int&&);
+
+private:
+  int&& X;
+};
+
+struct NonMovable {
+  NonMovable() = default;
+  NonMovable(NonMovable&&) = delete;
+  NonMovable& operator=(NonMovable&&) = delete;
+};
+
+struct DerivedFromNonMovable : NonMovable {};
+
+struct HasANonMovable {
+  NonMovable X;
+};
+
+#endif // TEST_SUPPORT_TYPE_CLASSIFICATION_MOVECONSTRUCTIBLE_H
diff --git a/.upstream-tests/test/support/type_classification/semiregular.h b/.upstream-tests/test/support/type_classification/semiregular.h
new file mode 100644
index 0000000000..24a1a789c1
--- /dev/null
+++ b/.upstream-tests/test/support/type_classification/semiregular.h
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TEST_SUPPORT_TYPE_CLASSIFICATION_H
+#define TEST_SUPPORT_TYPE_CLASSIFICATION_H
+
+#include "copyable.h"
+
+struct no_default_ctor {
+  no_default_ctor(int);
+};
+struct derived_from_non_default_initializable : no_default_ctor {};
+struct has_non_default_initializable {
+  no_default_ctor x;
+};
+
+struct deleted_default_ctor {
+  deleted_default_ctor() = delete;
+};
+struct derived_from_deleted_default_ctor : deleted_default_ctor {};
+struct has_deleted_default_ctor {
+  deleted_default_ctor x;
+};
+
+#endif // TEST_SUPPORT_TYPE_CLASSIFICATION_H
diff --git a/.upstream-tests/test/support/type_classification/swappable.h b/.upstream-tests/test/support/type_classification/swappable.h
new file mode 100644
index 0000000000..4383da06fe
--- /dev/null
+++ b/.upstream-tests/test/support/type_classification/swappable.h
@@ -0,0 +1,307 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+#ifndef TEST_SUPPORT_TYPE_CLASSIFICATION_SWAPPABLE_H
+#define TEST_SUPPORT_TYPE_CLASSIFICATION_SWAPPABLE_H
+
+#include <cuda/std/concepts>
+
+// `adl_swappable` indicates it's been swapped using ADL by maintaining a pointer to itself that
+// isn't a part of the exchange. This is well-formed since we say that two `adl_swappable` objects
+// are equal only if their respective `value` subobjects are equal and their respective `this`
+// subobjects store the addresses of those respective `adl_swappable` objects.
+class lvalue_adl_swappable {
+public:
+  lvalue_adl_swappable() = default;
+
+  __host__ __device__
+  constexpr lvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  __host__ __device__
+  constexpr lvalue_adl_swappable(lvalue_adl_swappable&& other) noexcept
+      : value_(cuda::std::move(other.value_)),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr lvalue_adl_swappable(lvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr lvalue_adl_swappable&
+  operator=(lvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  __host__ __device__
+  friend constexpr void swap(lvalue_adl_swappable& x,
+                             lvalue_adl_swappable& y) noexcept {
+    cuda::std::ranges::swap(x.value_, y.value_);
+  }
+
+  __host__ __device__
+  constexpr bool operator==(lvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  lvalue_adl_swappable* this_ = this;
+};
+
+class lvalue_rvalue_adl_swappable {
+public:
+  lvalue_rvalue_adl_swappable() = default;
+
+  __host__ __device__
+  constexpr lvalue_rvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  __host__ __device__
+  constexpr
+  lvalue_rvalue_adl_swappable(lvalue_rvalue_adl_swappable&& other) noexcept
+      : value_(cuda::std::move(other.value_)),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr
+  lvalue_rvalue_adl_swappable(lvalue_rvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr lvalue_rvalue_adl_swappable&
+  operator=(lvalue_rvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  __host__ __device__
+  friend constexpr void swap(lvalue_rvalue_adl_swappable& x,
+                             lvalue_rvalue_adl_swappable&& y) noexcept {
+    cuda::std::ranges::swap(x.value_, y.value_);
+  }
+
+  __host__ __device__
+  constexpr bool
+  operator==(lvalue_rvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  lvalue_rvalue_adl_swappable* this_ = this;
+};
+
+class rvalue_lvalue_adl_swappable {
+public:
+  rvalue_lvalue_adl_swappable() = default;
+
+  __host__ __device__
+  constexpr rvalue_lvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  __host__ __device__
+  constexpr
+  rvalue_lvalue_adl_swappable(rvalue_lvalue_adl_swappable&& other) noexcept
+      : value_(cuda::std::move(other.value_)),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr
+  rvalue_lvalue_adl_swappable(rvalue_lvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr rvalue_lvalue_adl_swappable&
+  operator=(rvalue_lvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  __host__ __device__
+  friend constexpr void swap(rvalue_lvalue_adl_swappable&& x,
+                             rvalue_lvalue_adl_swappable& y) noexcept {
+    cuda::std::ranges::swap(x.value_, y.value_);
+  }
+
+  __host__ __device__
+  constexpr bool
+  operator==(rvalue_lvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  rvalue_lvalue_adl_swappable* this_ = this;
+};
+
+class rvalue_adl_swappable {
+public:
+  rvalue_adl_swappable() = default;
+
+  __host__ __device__
+  constexpr rvalue_adl_swappable(int value) noexcept : value_(value) {}
+
+  __host__ __device__
+  constexpr rvalue_adl_swappable(rvalue_adl_swappable&& other) noexcept
+      : value_(cuda::std::move(other.value_)),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr rvalue_adl_swappable(rvalue_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr rvalue_adl_swappable&
+  operator=(rvalue_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  __host__ __device__
+  friend constexpr void swap(rvalue_adl_swappable&& x,
+                             rvalue_adl_swappable&& y) noexcept {
+    cuda::std::ranges::swap(x.value_, y.value_);
+  }
+
+  __host__ __device__
+  constexpr bool operator==(rvalue_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  rvalue_adl_swappable* this_ = this;
+};
+
+class non_move_constructible_adl_swappable {
+public:
+  non_move_constructible_adl_swappable() = default;
+
+  __host__ __device__
+  constexpr non_move_constructible_adl_swappable(int value) noexcept
+      : value_(value) {}
+
+  __host__ __device__
+  constexpr non_move_constructible_adl_swappable(
+      non_move_constructible_adl_swappable&& other) noexcept
+      : value_(cuda::std::move(other.value_)),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr non_move_constructible_adl_swappable(
+      non_move_constructible_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr non_move_constructible_adl_swappable&
+  operator=(non_move_constructible_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  __host__ __device__
+  friend constexpr void swap(non_move_constructible_adl_swappable& x,
+                             non_move_constructible_adl_swappable& y) noexcept {
+    cuda::std::ranges::swap(x.value_, y.value_);
+  }
+
+  __host__ __device__
+  constexpr bool
+  operator==(non_move_constructible_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  non_move_constructible_adl_swappable* this_ = this;
+};
+
+class non_move_assignable_adl_swappable {
+public:
+  non_move_assignable_adl_swappable() = default;
+
+  __host__ __device__
+  constexpr non_move_assignable_adl_swappable(int value) noexcept
+      : value_(value) {}
+
+  non_move_assignable_adl_swappable(non_move_assignable_adl_swappable&& other) =
+      delete;
+
+  __host__ __device__
+  constexpr non_move_assignable_adl_swappable(
+      non_move_assignable_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  constexpr non_move_assignable_adl_swappable&
+  operator=(non_move_assignable_adl_swappable&& other) noexcept = delete;
+  
+  __host__ __device__
+  friend constexpr void swap(non_move_assignable_adl_swappable& x,
+                             non_move_assignable_adl_swappable& y) noexcept {
+    cuda::std::ranges::swap(x.value_, y.value_);
+  }
+
+  __host__ __device__
+  constexpr bool
+  operator==(non_move_assignable_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  non_move_assignable_adl_swappable* this_ = this;
+};
+
+class throwable_adl_swappable {
+public:
+  throwable_adl_swappable() = default;
+
+  __host__ __device__
+  constexpr throwable_adl_swappable(int value) noexcept : value_(value) {}
+
+  __host__ __device__
+  constexpr throwable_adl_swappable(throwable_adl_swappable&& other) noexcept
+      : value_(cuda::std::move(other.value_)),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr
+  throwable_adl_swappable(throwable_adl_swappable const& other) noexcept
+      : value_(other.value_),
+        this_(this) {}
+
+  __host__ __device__
+  constexpr throwable_adl_swappable&
+  operator=(throwable_adl_swappable other) noexcept {
+    value_ = other.value_;
+    return *this;
+  }
+
+  __host__ __device__
+  friend constexpr void swap(throwable_adl_swappable& X,
+                             throwable_adl_swappable& Y) noexcept(false) {
+    cuda::std::ranges::swap(X.value_, Y.value_);
+  }
+
+  __host__ __device__
+  constexpr bool
+  operator==(throwable_adl_swappable const& other) const noexcept {
+    return value_ == other.value_ && this_ == this && other.this_ == &other;
+  }
+
+private:
+  int value_{};
+  throwable_adl_swappable* this_ = this;
+};
+
+#endif // TEST_SUPPORT_TYPE_CLASSIFICATION_SWAPPABLE_H
diff --git a/include/cuda/std/concepts b/include/cuda/std/concepts
new file mode 100644
index 0000000000..d492978e3e
--- /dev/null
+++ b/include/cuda/std/concepts
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the CUDA Toolkit, 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_CONCEPTS
+#define _CUDA_CONCEPTS
+
+#include "type_traits"
+#include "utility"
+#include "functional"
+
+#include "detail/__config"
+
+#include "detail/__pragma_push"
+
+#include "detail/__concepts"
+
+#include "detail/libcxx/include/__type_traits/copy_cv.h"
+#include "detail/libcxx/include/__type_traits/copy_cvref.h"
+#include "detail/libcxx/include/__type_traits/common_reference.h"
+
+#include "detail/libcxx/include/__concepts/_One_of.h"
+#include "detail/libcxx/include/__concepts/arithmetic.h"
+#include "detail/libcxx/include/__concepts/assignable.h"
+#include "detail/libcxx/include/__concepts/boolean_testable.h"
+#include "detail/libcxx/include/__concepts/class_or_enum.h"
+#include "detail/libcxx/include/__concepts/common_reference_with.h"
+#include "detail/libcxx/include/__concepts/common_with.h"
+#include "detail/libcxx/include/__concepts/constructible.h"
+#include "detail/libcxx/include/__concepts/convertible_to.h"
+#include "detail/libcxx/include/__concepts/copyable.h"
+#include "detail/libcxx/include/__concepts/derived_from.h"
+#include "detail/libcxx/include/__concepts/destructible.h"
+#include "detail/libcxx/include/__concepts/different_from.h"
+#include "detail/libcxx/include/__concepts/equality_comparable.h"
+#include "detail/libcxx/include/__concepts/invocable.h"
+#include "detail/libcxx/include/__concepts/movable.h"
+#include "detail/libcxx/include/__concepts/predicate.h"
+#include "detail/libcxx/include/__concepts/regular.h"
+#include "detail/libcxx/include/__concepts/relation.h"
+#include "detail/libcxx/include/__concepts/same_as.h"
+#include "detail/libcxx/include/__concepts/semiregular.h"
+#include "detail/libcxx/include/__concepts/swappable.h"
+#include "detail/libcxx/include/__concepts/totally_ordered.h"
+
+#include "detail/__pragma_pop"
+
+#endif //_CUDA_CONCEPTS
+
+
diff --git a/include/cuda/std/detail/__concepts b/include/cuda/std/detail/__concepts
new file mode 100644
index 0000000000..fed809ca06
--- /dev/null
+++ b/include/cuda/std/detail/__concepts
@@ -0,0 +1,278 @@
+//===----------------------------------------------------------------------===//
+//
+// Copyright (c) Facebook, Inc. and its affiliates.
+// Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___CONCEPTS
+#define _CUDA___CONCEPTS
+
+#include "__config"
+
+#if _LIBCUDACXX_STD_VER > 11
+
+#include <type_traits>
+
+#define _LIBCUDACXX_PP_CAT_(X, ...) X##__VA_ARGS__
+#define _LIBCUDACXX_PP_CAT(X, ...) _LIBCUDACXX_PP_CAT_(X, __VA_ARGS__)
+
+#define _LIBCUDACXX_PP_CAT2_(X, ...) X##__VA_ARGS__
+#define _LIBCUDACXX_PP_CAT2(X, ...) _LIBCUDACXX_PP_CAT2_(X, __VA_ARGS__)
+
+#define _LIBCUDACXX_PP_CAT3_(X, ...) X##__VA_ARGS__
+#define _LIBCUDACXX_PP_CAT3(X, ...) _LIBCUDACXX_PP_CAT3_(X, __VA_ARGS__)
+
+#define _LIBCUDACXX_PP_CAT4_(X, ...) X##__VA_ARGS__
+#define _LIBCUDACXX_PP_CAT4(X, ...) _LIBCUDACXX_PP_CAT4_(X, __VA_ARGS__)
+
+#define _LIBCUDACXX_PP_EVAL_(X, ARGS) X ARGS
+#define _LIBCUDACXX_PP_EVAL(X, ...) _LIBCUDACXX_PP_EVAL_(X, (__VA_ARGS__))
+
+#define _LIBCUDACXX_PP_EVAL2_(X, ARGS) X ARGS
+#define _LIBCUDACXX_PP_EVAL2(X, ...) _LIBCUDACXX_PP_EVAL2_(X, (__VA_ARGS__))
+
+#define _LIBCUDACXX_PP_EXPAND(...) __VA_ARGS__
+#define _LIBCUDACXX_PP_EAT(...)
+
+#define _LIBCUDACXX_PP_CHECK(...)                                              \
+  _LIBCUDACXX_PP_EXPAND(_LIBCUDACXX_PP_CHECK_N(__VA_ARGS__, 0, ))
+#define _LIBCUDACXX_PP_CHECK_N(x, n, ...) n
+#define _LIBCUDACXX_PP_PROBE(x) x, 1,
+#define _LIBCUDACXX_PP_PROBE_N(x, n) x, n,
+
+#define _LIBCUDACXX_PP_IS_PAREN(x)                                             \
+  _LIBCUDACXX_PP_CHECK(_LIBCUDACXX_PP_IS_PAREN_PROBE x)
+#define _LIBCUDACXX_PP_IS_PAREN_PROBE(...) _LIBCUDACXX_PP_PROBE(~)
+
+// The final _LIBCUDACXX_PP_EXPAND here is to avoid
+// https://stackoverflow.com/questions/5134523/msvc-doesnt-expand-va-args-correctly
+#define _LIBCUDACXX_PP_COUNT(...)                                              \
+  _LIBCUDACXX_PP_EXPAND(_LIBCUDACXX_PP_COUNT_(                                 \
+      __VA_ARGS__, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, \
+      35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18,  \
+      17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ))            \
+  /**/
+#define _LIBCUDACXX_PP_COUNT_(                                                 \
+    _01, _02, _03, _04, _05, _06, _07, _08, _09, _10, _11, _12, _13, _14, _15, \
+    _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
+    _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, \
+    _46, _47, _48, _49, _50, N, ...)                                           \
+  N /**/
+
+#define _LIBCUDACXX_PP_IIF(BIT) _LIBCUDACXX_PP_CAT_(_LIBCUDACXX_PP_IIF_, BIT)
+#define _LIBCUDACXX_PP_IIF_0(TRUE, ...) __VA_ARGS__
+#define _LIBCUDACXX_PP_IIF_1(TRUE, ...) TRUE
+
+#define _LIBCUDACXX_PP_LPAREN (
+
+#define _LIBCUDACXX_PP_NOT(BIT) _LIBCUDACXX_PP_CAT_(_LIBCUDACXX_PP_NOT_, BIT)
+#define _LIBCUDACXX_PP_NOT_0 1
+#define _LIBCUDACXX_PP_NOT_1 0
+
+#define _LIBCUDACXX_PP_EMPTY()
+#define _LIBCUDACXX_PP_COMMA() ,
+#define _LIBCUDACXX_PP_LBRACE() {
+#define _LIBCUDACXX_PP_RBRACE() }
+#define _LIBCUDACXX_PP_COMMA_IIF(X)                                            \
+  _LIBCUDACXX_PP_IIF(X)(_LIBCUDACXX_PP_EMPTY, _LIBCUDACXX_PP_COMMA)() /**/
+
+#define _LIBCUDACXX_PP_FOR_EACH(M, ...)                                        \
+  _LIBCUDACXX_PP_FOR_EACH_N(_LIBCUDACXX_PP_COUNT(__VA_ARGS__), M, __VA_ARGS__)
+#define _LIBCUDACXX_PP_FOR_EACH_N(N, M, ...)                                   \
+  _LIBCUDACXX_PP_CAT2(_LIBCUDACXX_PP_FOR_EACH_, N)(M, __VA_ARGS__)
+#define _LIBCUDACXX_PP_FOR_EACH_1(M, _1) M(_1)
+#define _LIBCUDACXX_PP_FOR_EACH_2(M, _1, _2) M(_1) M(_2)
+#define _LIBCUDACXX_PP_FOR_EACH_3(M, _1, _2, _3) M(_1) M(_2) M(_3)
+#define _LIBCUDACXX_PP_FOR_EACH_4(M, _1, _2, _3, _4) M(_1) M(_2) M(_3) M(_4)
+#define _LIBCUDACXX_PP_FOR_EACH_5(M, _1, _2, _3, _4, _5)                       \
+  M(_1) M(_2) M(_3) M(_4) M(_5)
+#define _LIBCUDACXX_PP_FOR_EACH_6(M, _1, _2, _3, _4, _5, _6)                   \
+  M(_1) M(_2) M(_3) M(_4) M(_5) M(_6)
+#define _LIBCUDACXX_PP_FOR_EACH_7(M, _1, _2, _3, _4, _5, _6, _7)               \
+  M(_1) M(_2) M(_3) M(_4) M(_5) M(_6) M(_7)
+#define _LIBCUDACXX_PP_FOR_EACH_8(M, _1, _2, _3, _4, _5, _6, _7, _8)           \
+  M(_1) M(_2) M(_3) M(_4) M(_5) M(_6) M(_7) M(_8)
+
+#define _LIBCUDACXX_PP_PROBE_EMPTY_PROBE__LIBCUDACXX_PP_PROBE_EMPTY            \
+  _LIBCUDACXX_PP_PROBE(~)
+
+#define _LIBCUDACXX_PP_PROBE_EMPTY()
+#define _LIBCUDACXX_PP_IS_NOT_EMPTY(...)                                       \
+  _LIBCUDACXX_PP_EVAL(                                                         \
+      _LIBCUDACXX_PP_CHECK,                                                    \
+      _LIBCUDACXX_PP_CAT(_LIBCUDACXX_PP_PROBE_EMPTY_PROBE_,                    \
+                         _LIBCUDACXX_PP_PROBE_EMPTY __VA_ARGS__()))            \
+  /**/
+
+#define _LIBCUDACXX_PP_TAIL(_, ...) __VA_ARGS__
+
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M0(REQ)                              \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_(REQ)(REQ)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M1(REQ) _LIBCUDACXX_PP_EXPAND REQ
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_(...)                                \
+  { _LIBCUDACXX_PP_FOR_EACH(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M, __VA_ARGS__) }
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_(REQ)                         \
+  _LIBCUDACXX_PP_CAT3(                                                         \
+      _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_,                               \
+      _LIBCUDACXX_PP_EVAL(                                                     \
+          _LIBCUDACXX_PP_CHECK,                                                \
+          _LIBCUDACXX_PP_CAT3(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_PROBE_, \
+                              REQ)))                                           \
+  /**/
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_PROBE_requires                \
+  _LIBCUDACXX_PP_PROBE_N(~, 1)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_PROBE_noexcept                \
+  _LIBCUDACXX_PP_PROBE_N(~, 2)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_PROBE_typename                \
+  _LIBCUDACXX_PP_PROBE_N(~, 3)
+
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_0 _LIBCUDACXX_PP_EXPAND
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_1                             \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_OR_NOEXCEPT
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_2                             \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_OR_NOEXCEPT
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_SELECT_3                             \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_OR_NOEXCEPT
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_OR_NOEXCEPT(REQ)            \
+  _LIBCUDACXX_PP_CAT4(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_, REQ)
+#define _LIBCUDACXX_PP_EAT_TYPENAME_PROBE_typename _LIBCUDACXX_PP_PROBE(~)
+#define _LIBCUDACXX_PP_EAT_TYPENAME_SELECT_(X, ...)                            \
+  _LIBCUDACXX_PP_CAT3(                                                         \
+      _LIBCUDACXX_PP_EAT_TYPENAME_SELECT_,                                     \
+      _LIBCUDACXX_PP_EVAL(                                                     \
+          _LIBCUDACXX_PP_CHECK,                                                \
+          _LIBCUDACXX_PP_CAT3(_LIBCUDACXX_PP_EAT_TYPENAME_PROBE_, X)))
+#define _LIBCUDACXX_PP_EAT_TYPENAME_(...)                                      \
+  _LIBCUDACXX_PP_EVAL2(_LIBCUDACXX_PP_EAT_TYPENAME_SELECT_, __VA_ARGS__, )     \
+  (__VA_ARGS__)
+#define _LIBCUDACXX_PP_EAT_TYPENAME_SELECT_0(...) __VA_ARGS__
+#define _LIBCUDACXX_PP_EAT_TYPENAME_SELECT_1(...)                              \
+  _LIBCUDACXX_PP_CAT3(_LIBCUDACXX_PP_EAT_TYPENAME_, __VA_ARGS__)
+#define _LIBCUDACXX_PP_EAT_TYPENAME_typename
+
+#if defined(__cpp_concepts) || defined(_LIBCUDACXX_DOXYGEN_INVOKED)
+
+#define _LIBCUDACXX_CONCEPT concept
+
+#define _LIBCUDACXX_CONCEPT_FRAGMENT(NAME, ...)                                \
+  concept NAME =                                                               \
+      _LIBCUDACXX_PP_CAT(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_, __VA_ARGS__)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_requires(...)                        \
+  requires(__VA_ARGS__) _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M(REQ)                               \
+  _LIBCUDACXX_PP_CAT2(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M,                     \
+                      _LIBCUDACXX_PP_IS_PAREN(REQ))                            \
+  (REQ);
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_requires(...)               \
+  requires __VA_ARGS__
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_typename(...)               \
+  typename _LIBCUDACXX_PP_EAT_TYPENAME_(__VA_ARGS__)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_noexcept(...)               \
+  { __VA_ARGS__ }                                                              \
+  noexcept
+
+#define _LIBCUDACXX_FRAGMENT(NAME, ...) NAME<__VA_ARGS__>
+
+#else
+
+#define _LIBCUDACXX_CONCEPT _LIBCUDACXX_INLINE_VAR constexpr bool
+
+#define _LIBCUDACXX_CONCEPT_FRAGMENT(NAME, ...)                                \
+  auto NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_impl_                                \
+          _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_##__VA_ARGS__ > {}                 \
+  template <typename... As>                                                    \
+  char NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_(                                    \
+      _CUDA_VSTD::_Concept::tag<As...> *,                                      \
+      decltype(&NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_impl_<As...>));             \
+  char(&NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_(...))[2] /**/
+#if defined(_MSC_VER) && !defined(__clang__)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_TRUE(...)                                 \
+  _CUDA_VSTD::_Concept::true_<decltype(_LIBCUDACXX_PP_FOR_EACH(                \
+      _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M, __VA_ARGS__) void())>()
+#else
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_TRUE(...)                                 \
+  !(decltype(_LIBCUDACXX_PP_FOR_EACH(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M,      \
+                                     __VA_ARGS__) void(),                      \
+             false){})
+#endif
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_requires(...)                        \
+  (__VA_ARGS__)->_CUDA_VSTD::enable_if_t < _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_2_
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_2_(...)                              \
+  _LIBCUDACXX_CONCEPT_FRAGMENT_TRUE(__VA_ARGS__)
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M(REQ)                               \
+  _LIBCUDACXX_PP_CAT2(_LIBCUDACXX_CONCEPT_FRAGMENT_REQS_M,                     \
+                      _LIBCUDACXX_PP_IS_PAREN(REQ))                            \
+  (REQ),
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_requires(...)               \
+  _CUDA_VSTD::requires_<__VA_ARGS__>
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_typename(...)               \
+  static_cast<_CUDA_VSTD::_Concept::tag<__VA_ARGS__> *>(nullptr)
+#if defined(__GNUC__) && !defined(__clang__)
+// GCC can't mangle noexcept expressions, so just check that the
+// expression is well-formed.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70790
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_noexcept(...) __VA_ARGS__
+#else
+#define _LIBCUDACXX_CONCEPT_FRAGMENT_REQS_REQUIRES_noexcept(...)               \
+  _CUDA_VSTD::requires_<noexcept(__VA_ARGS__)>
+#endif
+
+#define _LIBCUDACXX_FRAGMENT(NAME, ...)                                        \
+  (1u == sizeof(NAME##_LIBCUDACXX_CONCEPT_FRAGMENT_(                           \
+             static_cast<_CUDA_VSTD::_Concept::tag<__VA_ARGS__> *>(nullptr),   \
+             nullptr)))
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// _LIBCUDACXX_TEMPLATE
+// Usage:
+//   _LIBCUDACXX_TEMPLATE(typename A, typename B)
+//     (requires Concept1<A> _LIBCUDACXX_AND Concept2<B>)
+//   void foo(A a, B b)
+//   {}
+#if defined(__cpp_concepts)
+#define _LIBCUDACXX_TEMPLATE(...)                                              \
+  template <__VA_ARGS__> _LIBCUDACXX_PP_EXPAND /**/
+#define _LIBCUDACXX_AND &&                     /**/
+#else
+#define _LIBCUDACXX_TEMPLATE(...)                                              \
+  template <__VA_ARGS__ _LIBCUDACXX_TEMPLATE_SFINAE_AUX_ /**/
+#define _LIBCUDACXX_AND                                                        \
+  &&_LIBCUDACXX_true_, int > = 0, _CUDA_VSTD::enable_if_t < /**/
+#endif
+
+#define _LIBCUDACXX_TEMPLATE_SFINAE(...)                                       \
+  template <__VA_ARGS__ _LIBCUDACXX_TEMPLATE_SFINAE_AUX_ /**/
+#define _LIBCUDACXX_TEMPLATE_SFINAE_AUX_(...)                                  \
+  , bool _LIBCUDACXX_true_ = true,                                             \
+         _CUDA_VSTD::enable_if_t <                                             \
+                 _LIBCUDACXX_PP_CAT(_LIBCUDACXX_TEMPLATE_SFINAE_AUX_3_,        \
+                                    __VA_ARGS__) &&                            \
+             _LIBCUDACXX_true_,                                                \
+         int > = 0 > /**/
+#define _LIBCUDACXX_TEMPLATE_SFINAE_AUX_3_requires
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+namespace _Concept {
+template <typename...> struct tag;
+template <class> inline constexpr bool true_() { return true; }
+} // namespace _Concept
+
+#if defined(__clang__) || defined(_MSC_VER)
+template <bool B> _CUDA_VSTD::enable_if_t<B> requires_() {}
+#else
+template <bool B>
+_LIBCUDACXX_INLINE_VAR constexpr _CUDA_VSTD::enable_if_t<B, int> requires_ = 0;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#endif //_CUDA___CONCEPTS
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/_One_of.h b/include/cuda/std/detail/libcxx/include/__concepts/_One_of.h
new file mode 100644
index 0000000000..723bc86fc0
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/_One_of.h
@@ -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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_ONE_OF_H
+#define _LIBCUDACXX___CONCEPTS_ONE_OF_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 14
+template <class _Ty, class... _Others>
+_LIBCUDACXX_CONCEPT _One_of = (_CUDA_VSTD::is_same_v<_Ty, _Others> || ...);
+#else if _LIBCUDACXX_STD_VER > 11
+template <class _Ty, class... _Others>
+_LIBCUDACXX_CONCEPT _One_of =
+    _CUDA_VSTD::disjunction_v<_CUDA_VSTD::is_same<_Ty, _Others>...>;
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_ONE_OF_H
\ No newline at end of file
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/arithmetic.h b/include/cuda/std/detail/libcxx/include/__concepts/arithmetic.h
new file mode 100644
index 0000000000..5864a23d7b
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/arithmetic.h
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_ARITHMETIC_H
+#define _LIBCUDACXX___CONCEPTS_ARITHMETIC_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concepts.arithmetic], arithmetic concepts
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT integral = is_integral_v<_Tp>;
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT signed_integral = integral<_Tp> && is_signed_v<_Tp>;
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT floating_point = is_floating_point_v<_Tp>;
+
+// Concept helpers for the internal type traits for the fundamental types.
+
+#ifndef __cuda_std__
+template <class _Tp>
+_LIBCUDACXX_CONCEPT __LIBCUDACXX_unsigned_integer = __LIBCUDACXX_is_unsigned_integer<_Tp>::value;
+template <class _Tp>
+_LIBCUDACXX_CONCEPT __LIBCUDACXX_signed_integer = __LIBCUDACXX_is_signed_integer<_Tp>::value;
+#endif
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_ARITHMETIC_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/assignable.h b/include/cuda/std/detail/libcxx/include/__concepts/assignable.h
new file mode 100644
index 0000000000..fcb1abd14a
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/assignable.h
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_ASSIGNABLE_H
+#define _LIBCUDACXX___CONCEPTS_ASSIGNABLE_H
+
+#ifndef __cuda_std__
+#include <__concepts/common_reference_with.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <utility>
+#include <type_traits>
+#else 
+#include "common_reference_with.h"
+#include "same_as.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.assignable]
+
+template<class _Lhs, class _Rhs>
+concept assignable_from =
+  is_lvalue_reference_v<_Lhs> &&
+  common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
+  requires (_Lhs __lhs, _Rhs&& __rhs) {
+    { __lhs = _CUDA_VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
+  };
+
+#else if _LIBCUDACXX_STD_VER > 11
+
+template<class _Lhs, class _Rhs>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Assignable_from_,
+  requires(_Lhs __lhs, _Rhs&& __rhs) //
+  (__lhs = _CUDA_VSTD::forward<_Rhs>(__rhs)));
+
+template<class _Lhs, class _Rhs>
+_LIBCUDACXX_CONCEPT assignable_from =
+  is_lvalue_reference_v<_Lhs> &&
+  common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
+  _LIBCUDACXX_FRAGMENT(_Assignable_from_, _Lhs, _Rhs);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_ASSIGNABLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/boolean_testable.h b/include/cuda/std/detail/libcxx/include/__concepts/boolean_testable.h
new file mode 100644
index 0000000000..a788bf5f12
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/boolean_testable.h
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_BOOLEAN_TESTABLE_H
+#define _LIBCUDACXX___CONCEPTS_BOOLEAN_TESTABLE_H
+
+#ifndef __cuda_std__
+#include <__concepts/convertible_to.h>
+#include <__config>
+#include <utility>
+#else
+#include "convertible_to.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concepts.booleantestable]
+
+template<class _Tp>
+concept __boolean_testable_impl = convertible_to<_Tp, bool>;
+
+template<class _Tp>
+concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
+  { !_CUDA_VSTD::forward<_Tp>(__t) } -> __boolean_testable_impl;
+};
+
+#else if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __boolean_testable_impl = convertible_to<_Tp, bool>;
+
+_LIBCUDACXX_TEMPLATE(class _Tp)
+  (requires __boolean_testable_impl<_Tp>) //
+void _Returns_boolean_testable(_Tp) {}
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __boolean_testable_,
+  requires(_Tp&& __t) //
+  (_Returns_boolean_testable(!_CUDA_VSTD::forward<_Tp>(__t))));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __boolean_testable = __boolean_testable_impl<_Tp> &&
+  _LIBCUDACXX_FRAGMENT(__boolean_testable_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_BOOLEAN_TESTABLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/class_or_enum.h b/include/cuda/std/detail/libcxx/include/__concepts/class_or_enum.h
new file mode 100644
index 0000000000..9fffc311c1
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/class_or_enum.h
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_CLASS_OR_ENUM_H
+#define _LIBCUDACXX___CONCEPTS_CLASS_OR_ENUM_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
+
+// Work around Clang bug https://llvm.org/PR52970
+// TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14).
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __workaround_52970 = is_class_v<__uncvref_t<_Tp>> || is_union_v<__uncvref_t<_Tp>>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_CLASS_OR_ENUM_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/common_reference_with.h b/include/cuda/std/detail/libcxx/include/__concepts/common_reference_with.h
new file mode 100644
index 0000000000..68ce1080d6
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/common_reference_with.h
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_COMMON_REFERENCE_WITH_H
+#define _LIBCUDACXX___CONCEPTS_COMMON_REFERENCE_WITH_H
+
+#ifndef __cuda_std__
+#include <__concepts/convertible_to.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <type_traits>
+#else
+#include "convertible_to.h"
+#include "same_as.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.commonref]
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Common_reference_exists_,
+  requires() //
+  (typename(_CUDA_VSTD::common_reference_t<_Tp, _Up>),
+   typename(_CUDA_VSTD::common_reference_t<_Up, _Tp>)));
+   
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT _Common_reference_exists = _LIBCUDACXX_FRAGMENT(_Common_reference_exists_, _Tp, _Up);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Common_reference_with_impl,
+  requires()(0) &&
+  same_as<_CUDA_VSTD::common_reference_t<_Tp, _Up>, _CUDA_VSTD::common_reference_t<_Up, _Tp>> &&
+  convertible_to<_Tp, _CUDA_VSTD::common_reference_t<_Tp, _Up>> &&
+  convertible_to<_Up, _CUDA_VSTD::common_reference_t<_Tp, _Up>>);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT common_reference_with = _Common_reference_exists<_Tp, _Up> && _LIBCUDACXX_FRAGMENT(_Common_reference_with_impl, _Tp, _Up);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_COMMON_REFERENCE_WITH_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/common_with.h b/include/cuda/std/detail/libcxx/include/__concepts/common_with.h
new file mode 100644
index 0000000000..d03fbfdb82
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/common_with.h
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_COMMON_WITH_H
+#define _LIBCUDACXX___CONCEPTS_COMMON_WITH_H
+
+#ifndef __cuda_std__
+#include <__concepts/common_reference_with.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <type_traits>
+#else
+#include "common_reference_with.h"
+#include "same_as.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.common]
+
+template<class _Tp, class _Up>
+concept common_with =
+  same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
+  requires {
+    static_cast<common_type_t<_Tp, _Up>>(declval<_Tp>());
+    static_cast<common_type_t<_Tp, _Up>>(declval<_Up>());
+  } &&
+  common_reference_with<
+    add_lvalue_reference_t<const _Tp>,
+    add_lvalue_reference_t<const _Up>> &&
+  common_reference_with<
+    add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
+    common_reference_t<
+      add_lvalue_reference_t<const _Tp>,
+      add_lvalue_reference_t<const _Up>>>;
+
+#else if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Common_type_exists_,
+  requires() //
+  (typename(_CUDA_VSTD::common_type_t<_Tp, _Up>),
+   typename(_CUDA_VSTD::common_type_t<_Up, _Tp>)));
+   
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT _Common_type_exists = _LIBCUDACXX_FRAGMENT(_Common_type_exists_, _Tp, _Up);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Common_type_constructible_,
+  requires() //
+  (static_cast<_CUDA_VSTD::common_type_t<_Tp, _Up>>(declval<_Tp>()),
+   static_cast<_CUDA_VSTD::common_type_t<_Tp, _Up>>(declval<_Up>())));
+   
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT _Common_type_constructible = _Common_type_exists<_Tp, _Up> && _LIBCUDACXX_FRAGMENT(_Common_type_constructible_, _Tp, _Up);
+
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Common_with_impl,
+  requires()(0) &&
+  same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
+  common_reference_with<
+    add_lvalue_reference_t<const _Tp>,
+    add_lvalue_reference_t<const _Up>> &&
+  common_reference_with<
+    add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
+    common_reference_t<
+      add_lvalue_reference_t<const _Tp>,
+      add_lvalue_reference_t<const _Up>>>);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT common_with = _Common_type_constructible<_Tp, _Up> && _LIBCUDACXX_FRAGMENT(_Common_with_impl, _Tp, _Up);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_COMMON_WITH_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/constructible.h b/include/cuda/std/detail/libcxx/include/__concepts/constructible.h
new file mode 100644
index 0000000000..5fd4122dfd
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/constructible.h
@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___CONCEPTS_CONSTRUCTIBLE_H
+
+#ifndef __cuda_std__
+#include <__concepts/convertible_to.h>
+#include <__concepts/destructible.h>
+#include <__config>
+#include <type_traits>
+#else
+#include "convertible_to.h"
+#include "destructible.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.constructible]
+template<class _Tp, class... _Args>
+concept constructible_from =
+    destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
+
+// [concept.default.init]
+template<class _Tp>
+concept __default_initializable = requires { ::new _Tp; };
+
+template<class _Tp>
+concept default_initializable = constructible_from<_Tp> &&
+    requires { _Tp{}; } && __default_initializable<_Tp>;
+
+// [concept.moveconstructible]
+template<class _Tp>
+concept move_constructible =
+  constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
+
+// [concept.copyconstructible]
+template<class _Tp>
+concept copy_constructible =
+  move_constructible<_Tp> &&
+  constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
+  constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
+  constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
+
+#else if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class... _Args>
+_LIBCUDACXX_CONCEPT constructible_from =
+    destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __default_initializable_,
+  requires() //
+  ((::new _Tp)));
+  
+template<class _Tp>
+_LIBCUDACXX_CONCEPT __default_initializable = _LIBCUDACXX_FRAGMENT(__default_initializable_, _Tp);
+  
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Default_initializable_,
+  requires() //
+  (_Tp{}));
+template<class _Tp>
+_LIBCUDACXX_CONCEPT default_initializable = constructible_from<_Tp> &&
+    _LIBCUDACXX_FRAGMENT(_Default_initializable_, _Tp) && __default_initializable<_Tp>;
+
+// [concept.moveconstructible]
+template<class _Tp>
+_LIBCUDACXX_CONCEPT move_constructible =
+  constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
+
+// [concept.copyconstructible]
+template<class _Tp>
+_LIBCUDACXX_CONCEPT copy_constructible =
+  move_constructible<_Tp> &&
+  constructible_from<_Tp, add_lvalue_reference_t<_Tp>> && convertible_to<add_lvalue_reference_t<_Tp>, _Tp> &&
+  constructible_from<_Tp, const add_lvalue_reference_t<_Tp>> && convertible_to<const add_lvalue_reference_t<_Tp>, _Tp> &&
+  constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_CONSTRUCTIBLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/convertible_to.h b/include/cuda/std/detail/libcxx/include/__concepts/convertible_to.h
new file mode 100644
index 0000000000..fea90d5ee8
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/convertible_to.h
@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_CONVERTIBLE_TO_H
+#define _LIBCUDACXX___CONCEPTS_CONVERTIBLE_TO_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <utility>
+#include <type_traits>
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.convertible]
+
+template<class _From, class _To>
+concept convertible_to =
+  is_convertible_v<_From, _To> &&
+  requires {
+    static_cast<_To>(declval<_From>());
+  };
+
+#else
+
+template<class _From, class _To>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Convertible_to_,
+  requires() //
+  (static_cast<_To>(declval<_From>())));
+
+template<class _From, class _To>
+_LIBCUDACXX_CONCEPT convertible_to =
+  is_convertible_v<_From, _To> && _LIBCUDACXX_FRAGMENT(_Convertible_to_, _From, _To);
+
+#endif // _LIBCUDACXX_STD_VER > 17
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_CONVERTIBLE_TO_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/copyable.h b/include/cuda/std/detail/libcxx/include/__concepts/copyable.h
new file mode 100644
index 0000000000..99861afb47
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/copyable.h
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_COPYABLE_H
+#define _LIBCUDACXX___CONCEPTS_COPYABLE_H
+
+#ifndef __cuda_std__
+#include <__concepts/assignable.h>
+#include <__concepts/constructible.h>
+#include <__concepts/movable.h>
+#include <__config>
+#else
+#include "assignable.h"
+#include "constructible.h"
+#include "movable.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concepts.object]
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Copyable_,
+  requires()(0) && movable<_Tp> &&
+  assignable_from<_Tp&, _Tp&> &&
+  assignable_from<_Tp&, const _Tp&> &&
+  assignable_from<_Tp&, const _Tp>);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT copyable = copy_constructible<_Tp> &&
+  _LIBCUDACXX_FRAGMENT(_Copyable_,_Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_COPYABLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/derived_from.h b/include/cuda/std/detail/libcxx/include/__concepts/derived_from.h
new file mode 100644
index 0000000000..8560e1509a
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/derived_from.h
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_DERIVED_FROM_H
+#define _LIBCUDACXX___CONCEPTS_DERIVED_FROM_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.derived]
+
+template<class _Dp, class _Bp>
+_LIBCUDACXX_CONCEPT derived_from =
+  is_base_of_v<_Bp, _Dp> &&
+#if _LIBCUDACXX_STD_VER > 17
+  is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
+#else
+  is_convertible_v<add_pointer_t<const volatile _Dp>, add_pointer_t<const volatile _Bp>>;
+#endif // _LIBCUDACXX_STD_VER > 17
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_DERIVED_FROM_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/destructible.h b/include/cuda/std/detail/libcxx/include/__concepts/destructible.h
new file mode 100644
index 0000000000..fa0e9f7f5f
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/destructible.h
@@ -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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_DESTRUCTIBLE_H
+#define _LIBCUDACXX___CONCEPTS_DESTRUCTIBLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.destructible]
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT destructible = is_nothrow_destructible_v<_Tp>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_DESTRUCTIBLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/different_from.h b/include/cuda/std/detail/libcxx/include/__concepts/different_from.h
new file mode 100644
index 0000000000..0d6726d27c
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/different_from.h
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H
+#define _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H
+
+#ifndef __cuda_std__
+#include <__concepts/same_as.h>
+#include <__config>
+#include <type_traits>
+#else
+#include "same_as.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/equality_comparable.h b/include/cuda/std/detail/libcxx/include/__concepts/equality_comparable.h
new file mode 100644
index 0000000000..bd9f4f0e58
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/equality_comparable.h
@@ -0,0 +1,111 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_EQUALITY_COMPARABLE_H
+#define _LIBCUDACXX___CONCEPTS_EQUALITY_COMPARABLE_H
+
+#ifndef __cuda_std__
+#include <__concepts/boolean_testable.h>
+#include <__concepts/common_reference_with.h>
+#include <__config>
+#include <type_traits>
+#else
+#include "boolean_testable.h"
+#include "common_reference_with.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.equalitycomparable]
+
+template<class _Tp, class _Up>
+concept __weakly_equality_comparable_with =
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+    { __t == __u } -> __boolean_testable;
+    { __t != __u } -> __boolean_testable;
+    { __u == __t } -> __boolean_testable;
+    { __u != __t } -> __boolean_testable;
+  };
+
+template<class _Tp>
+concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+concept equality_comparable_with =
+  equality_comparable<_Tp> && equality_comparable<_Up> &&
+  common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
+  equality_comparable<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>> &&
+  __weakly_equality_comparable_with<_Tp, _Up>;
+  
+#else if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _With_lvalue_reference_,
+  requires()(
+    typename(__make_const_lvalue_ref<_Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT _With_lvalue_reference = _LIBCUDACXX_FRAGMENT(_With_lvalue_reference_, _Tp);
+
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __weakly_equality_comparable_with_,
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) //
+  (_Returns_boolean_testable(__t == __u),
+   _Returns_boolean_testable(__t != __u),
+   _Returns_boolean_testable(__u == __t),
+   _Returns_boolean_testable(__u != __t)));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __weakly_equality_comparable_with = 
+  _With_lvalue_reference<_Tp> && _With_lvalue_reference<_Up> && 
+  _LIBCUDACXX_FRAGMENT(__weakly_equality_comparable_with_, _Tp, _Up);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Equality_comparable_with_,
+  requires() (0) &&
+  equality_comparable<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>> &&
+  __weakly_equality_comparable_with<_Tp, _Up>);
+  
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Equality_comparable_with2_,
+  requires() (0) &&
+  common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT equality_comparable_with =
+  equality_comparable<_Tp> && equality_comparable<_Up> &&
+  _LIBCUDACXX_FRAGMENT(_Equality_comparable_with2_, _Tp, _Up) &&
+  _LIBCUDACXX_FRAGMENT(_Equality_comparable_with_, _Tp, _Up);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_EQUALITY_COMPARABLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/invocable.h b/include/cuda/std/detail/libcxx/include/__concepts/invocable.h
new file mode 100644
index 0000000000..66cc377539
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/invocable.h
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_INVOCABLE_H
+#define _LIBCUDACXX___CONCEPTS_INVOCABLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <functional>
+#include <utility>
+#include <type_traits>
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.invocable]
+
+template<class _Fn, class... _Args>
+concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
+  _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__fn), _CUDA_VSTD::forward<_Args>(__args)...); // not required to be equality preserving
+};
+
+// [concept.regular.invocable]
+
+template<class _Fn, class... _Args>
+concept regular_invocable = invocable<_Fn, _Args...>;
+
+#else if _LIBCUDACXX_STD_VER > 11
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Invocable_,
+  requires(_Fn&& __fn, _Args&&... __args) //
+  (_CUDA_VSTD::__invoke(_CUDA_VSTD::forward<_Fn>(__fn), _CUDA_VSTD::forward<_Args>(__args)...)));
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT invocable = _LIBCUDACXX_FRAGMENT(_Invocable_, _Fn, _Args...);
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT regular_invocable = invocable<_Fn, _Args...>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_INVOCABLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/movable.h b/include/cuda/std/detail/libcxx/include/__concepts/movable.h
new file mode 100644
index 0000000000..c1181f79fa
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/movable.h
@@ -0,0 +1,59 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_MOVABLE_H
+#define _LIBCUDACXX___CONCEPTS_MOVABLE_H
+
+#ifndef __cuda_std__
+#include <__concepts/assignable.h>
+#include <__concepts/constructible.h>
+#include <__concepts/swappable.h>
+#include <__config>
+#include <type_traits>
+#else
+#include "assignable.h"
+#include "constructible.h"
+#include "swappable.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+template<class _Tp>
+concept movable =
+  is_object_v<_Tp> && 
+  move_constructible<_Tp>&&
+  assignable_from<_Tp&, _Tp> &&
+  swappable<_Tp>;
+
+#else
+
+// [concepts.object]
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Movable_,
+  requires()(0) && move_constructible<_Tp>&&
+  assignable_from<_Tp&, _Tp> &&
+  swappable<_Tp>);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT movable =
+  is_object_v<_Tp> &&
+  _LIBCUDACXX_FRAGMENT(_Movable_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_MOVABLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/predicate.h b/include/cuda/std/detail/libcxx/include/__concepts/predicate.h
new file mode 100644
index 0000000000..2aa7962b2f
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/predicate.h
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_PREDICATE_H
+#define _LIBCUDACXX___CONCEPTS_PREDICATE_H
+
+#ifndef __cuda_std__
+#include <__concepts/boolean_testable.h>
+#include <__concepts/invocable.h>
+#include <__config>
+#include <type_traits>
+#else
+#include "boolean_testable.h"
+#include "invocable.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+template<class _Fn, class... _Args>
+concept predicate =
+  regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
+
+#else
+
+// [concept.predicate]
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Predicate_,
+  requires()(0) && __boolean_testable<invoke_result_t<_Fn, _Args...>>);
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT predicate =
+  regular_invocable<_Fn, _Args...> && _LIBCUDACXX_FRAGMENT(_Predicate_, _Fn, _Args...);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_PREDICATE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/regular.h b/include/cuda/std/detail/libcxx/include/__concepts/regular.h
new file mode 100644
index 0000000000..d09a25ef8a
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/regular.h
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_REGULAR_H
+#define _LIBCUDACXX___CONCEPTS_REGULAR_H
+
+#ifndef __cuda_std__
+#include <__concepts/equality_comparable.h>
+#include <__concepts/semiregular.h>
+#include <__config>
+#else
+#include "equality_comparable.h"
+#include "semiregular.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.object]
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT regular = semiregular<_Tp> && equality_comparable<_Tp>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_REGULAR_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/relation.h b/include/cuda/std/detail/libcxx/include/__concepts/relation.h
new file mode 100644
index 0000000000..c0b9327c3a
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/relation.h
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_RELATION_H
+#define _LIBCUDACXX___CONCEPTS_RELATION_H
+
+#ifndef __cuda_std__
+#include <__concepts/predicate.h>
+#include <__config>
+#else
+#include "predicate.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.relation]
+
+template<class _Rp, class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT relation =
+  predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> &&
+  predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
+
+// [concept.equiv]
+
+template<class _Rp, class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT equivalence_relation = relation<_Rp, _Tp, _Up>;
+
+// [concept.strictweakorder]
+
+template<class _Rp, class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT strict_weak_order = relation<_Rp, _Tp, _Up>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_RELATION_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/same_as.h b/include/cuda/std/detail/libcxx/include/__concepts/same_as.h
new file mode 100644
index 0000000000..8b4d553d0a
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/same_as.h
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_SAME_AS_H
+#define _LIBCUDACXX___CONCEPTS_SAME_AS_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.same]
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __same_as_impl = _IsSame<_Tp, _Up>::value;
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
+
+_LIBCUDACXX_TEMPLATE(class _Tp, class _Up)
+  (requires same_as<_Tp, _Up>) //
+void _Returns_exactly(_Up) {}
+
+_LIBCUDACXX_TEMPLATE(class _Bool_constant)
+  (requires _Bool_constant::value) //
+void _Returns_true() {}
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_SAME_AS_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/semiregular.h b/include/cuda/std/detail/libcxx/include/__concepts/semiregular.h
new file mode 100644
index 0000000000..99ee2e1dd6
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/semiregular.h
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H
+#define _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H
+
+#ifndef __cuda_std__
+#include <__concepts/constructible.h>
+#include <__concepts/copyable.h>
+#include <__config>
+#else
+#include "constructible.h"
+#include "copyable.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.object]
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT semiregular = copyable<_Tp> && default_initializable<_Tp>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/swappable.h b/include/cuda/std/detail/libcxx/include/__concepts/swappable.h
new file mode 100644
index 0000000000..4e42c6eb1a
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/swappable.h
@@ -0,0 +1,225 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_SWAPPABLE_H
+#define _LIBCUDACXX___CONCEPTS_SWAPPABLE_H
+
+#ifndef __cuda_std__
+#include <__concepts/assignable.h>
+#include <__concepts/class_or_enum.h>
+#include <__concepts/common_reference_with.h>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <utility>
+#include <type_traits>
+#else
+#include "assignable.h"
+#include "class_or_enum.h"
+#include "common_reference_with.h"
+#include "constructible.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.swappable]
+
+namespace ranges {
+namespace __swap {
+
+  template<class _Tp>
+  void swap(_Tp&, _Tp&) = delete;
+
+  template<class _Tp, class _Up>
+  concept __unqualified_swappable_with =
+    (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
+    requires(_Tp&& __t, _Up&& __u) {
+      swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u));
+    };
+
+  struct __fn;
+
+  template<class _Tp, class _Up, size_t _Size>
+  concept __swappable_arrays =
+    !__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
+    extent_v<_Tp> == extent_v<_Up> &&
+    requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
+      __swap(__t[0], __u[0]);
+    };
+
+  template<class _Tp>
+  concept __exchangeable =
+    !__unqualified_swappable_with<_Tp&, _Tp&> &&
+    move_constructible<_Tp> &&
+    assignable_from<_Tp&, _Tp>;
+
+  struct __fn {
+    // 2.1   `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
+    // *The name `swap` is used here unqualified.
+    template<class _Tp, class _Up>
+      requires __unqualified_swappable_with<_Tp, _Up>
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr void operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u))))
+    {
+      swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u));
+    }
+
+    // 2.2   Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
+    template<class _Tp, class _Up, size_t _Size>
+      requires __swappable_arrays<_Tp, _Up, _Size>
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
+      noexcept(noexcept((*this)(*__t, *__u)))
+    {
+      // TODO(cjdb): replace with `ranges::swap_ranges`.
+      for (size_t __i = 0; __i < _Size; ++__i) {
+        (*this)(__t[__i], __u[__i]);
+      }
+    }
+
+    // 2.3   Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
+    template<__exchangeable _Tp>
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr void operator()(_Tp& __x, _Tp& __y) const
+      noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
+    {
+      __y = _CUDA_VSTD::exchange(__x, _CUDA_VSTD::move(__y));
+    }
+  };
+} // namespace __swap
+
+inline namespace __cpo {
+  inline constexpr auto swap = __swap::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+template<class _Tp>
+concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
+
+template<class _Tp, class _Up>
+concept swappable_with =
+  common_reference_with<_Tp, _Up> &&
+  requires(_Tp&& __t, _Up&& __u) {
+    ranges::swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Tp>(__t));
+    ranges::swap(_CUDA_VSTD::forward<_Up>(__u), _CUDA_VSTD::forward<_Up>(__u));
+    ranges::swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u));
+    ranges::swap(_CUDA_VSTD::forward<_Up>(__u), _CUDA_VSTD::forward<_Tp>(__t));
+  };
+
+#else if _LIBCUDACXX_STD_VER > 11
+
+namespace ranges {
+namespace __swap {
+
+  template<class _Tp>
+  void swap(_Tp&, _Tp&) = delete;
+  
+  template<class _Tp, class _Up>
+  _LIBCUDACXX_CONCEPT_FRAGMENT(
+    __unqualified_swappable_with_,
+    requires(_Tp&& __t, _Up&& __u) //
+    (swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u))));
+
+  template<class _Tp, class _Up>
+  _LIBCUDACXX_CONCEPT __unqualified_swappable_with =
+    (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
+    _LIBCUDACXX_FRAGMENT(__unqualified_swappable_with_, _Tp, _Up);
+
+  struct __fn;
+  
+  template<class _Tp, class _Up, class _Size>
+  _LIBCUDACXX_CONCEPT_FRAGMENT(
+    __swappable_arrays_,
+    requires(_Tp(& __t)[_Size::value], _Up(& __u)[_Size::value], const __fn& __swap) //
+    (__swap(__t[0], __u[0])));
+
+  template<class _Tp, class _Up, size_t _Size>
+  _LIBCUDACXX_CONCEPT __swappable_arrays =
+    !__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
+    extent_v<_Tp> == extent_v<_Up> &&
+    _LIBCUDACXX_FRAGMENT(__swappable_arrays_, _Tp, _Up, _CUDA_VSTD::integral_constant<size_t, _Size>);
+
+  template<class _Tp>
+  _LIBCUDACXX_CONCEPT __exchangeable =
+    !__unqualified_swappable_with<_Tp&, _Tp&> &&
+    move_constructible<_Tp> &&
+    assignable_from<_Tp&, _Tp>;
+
+  struct __fn {
+    // 2.1   `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
+    // *The name `swap` is used here unqualified.
+    _LIBCUDACXX_TEMPLATE(class _Tp, class _Up)
+      (requires __unqualified_swappable_with<_Tp, _Up>)
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr void operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u))))
+    {
+      swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u));
+    }
+
+    // 2.2   Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
+    _LIBCUDACXX_TEMPLATE(class _Tp, class _Up, size_t _Size)
+      (requires __swappable_arrays<_Tp, _Up, _Size>)      
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
+      noexcept(noexcept((*this)(*__t, *__u)))
+    {
+      // TODO(cjdb): replace with `ranges::swap_ranges`.
+      for (size_t __i = 0; __i < _Size; ++__i) {
+        (*this)(__t[__i], __u[__i]);
+      }
+    }
+
+    // 2.3   Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
+    _LIBCUDACXX_TEMPLATE(class _Tp)
+      (requires __exchangeable<_Tp>)      
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr void operator()(_Tp& __x, _Tp& __y) const
+      noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
+    {
+      __y = _CUDA_VSTD::exchange(__x, _CUDA_VSTD::move(__y));
+    }
+  };
+} // namespace __swap
+
+inline namespace __cpo {
+  inline constexpr auto swap = __swap::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Swappable_,
+  requires(_Tp& __a, _Tp& __b) //
+  (_CUDA_VSTD::ranges::swap(__a, __b)));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT swappable = _LIBCUDACXX_FRAGMENT(_Swappable_, _Tp);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Swappable_with_,
+  requires(_Tp&& __t, _Up&& __u) //
+  (_CUDA_VSTD::ranges::swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Tp>(__t)),
+   _CUDA_VSTD::ranges::swap(_CUDA_VSTD::forward<_Up>(__u), _CUDA_VSTD::forward<_Up>(__u)),
+   _CUDA_VSTD::ranges::swap(_CUDA_VSTD::forward<_Tp>(__t), _CUDA_VSTD::forward<_Up>(__u)),
+   _CUDA_VSTD::ranges::swap(_CUDA_VSTD::forward<_Up>(__u), _CUDA_VSTD::forward<_Tp>(__t))));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT swappable_with = common_reference_with<_Tp, _Up> &&
+  _LIBCUDACXX_FRAGMENT(_Swappable_with_, _Tp, _Up);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_SWAPPABLE_H
diff --git a/include/cuda/std/detail/libcxx/include/__concepts/totally_ordered.h b/include/cuda/std/detail/libcxx/include/__concepts/totally_ordered.h
new file mode 100644
index 0000000000..0c09b8ce97
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__concepts/totally_ordered.h
@@ -0,0 +1,100 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_TOTALLY_ORDERED_H
+#define _LIBCUDACXX___CONCEPTS_TOTALLY_ORDERED_H
+
+#ifndef __cuda_std__
+#include <__concepts/boolean_testable.h>
+#include <__concepts/equality_comparable.h>
+#include <__config>
+#include <type_traits>
+#else
+#include "boolean_testable.h"
+#include "equality_comparable.h"
+#endif //__cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.totallyordered]
+
+template<class _Tp, class _Up>
+concept __partially_ordered_with =
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+    { __t <  __u } -> __boolean_testable;
+    { __t >  __u } -> __boolean_testable;
+    { __t <= __u } -> __boolean_testable;
+    { __t >= __u } -> __boolean_testable;
+    { __u <  __t } -> __boolean_testable;
+    { __u >  __t } -> __boolean_testable;
+    { __u <= __t } -> __boolean_testable;
+    { __u >= __t } -> __boolean_testable;
+  };
+
+template<class _Tp>
+concept totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+concept totally_ordered_with =
+  totally_ordered<_Tp> && totally_ordered<_Up> &&
+  equality_comparable_with<_Tp, _Up> &&
+  totally_ordered<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>> &&
+  __partially_ordered_with<_Tp, _Up>;
+
+#else if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __partially_ordered_with_,
+  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) //
+  (_Returns_boolean_testable(__t <  __u),
+   _Returns_boolean_testable(__t >  __u),
+   _Returns_boolean_testable(__t <= __u),
+   _Returns_boolean_testable(__t >= __u),
+   _Returns_boolean_testable(__u <  __t),
+   _Returns_boolean_testable(__u >  __t),
+   _Returns_boolean_testable(__u <= __t),
+   _Returns_boolean_testable(__u >= __t)));
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __partially_ordered_with = _LIBCUDACXX_FRAGMENT(__partially_ordered_with_, _Tp, _Up);
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  _Totally_ordered_with_,
+  requires() (0) &&
+  totally_ordered<
+    common_reference_t<
+      __make_const_lvalue_ref<_Tp>,
+      __make_const_lvalue_ref<_Up>>> &&
+  __partially_ordered_with<_Tp, _Up>);
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT totally_ordered_with =
+  totally_ordered<_Tp> && totally_ordered<_Up> &&
+  equality_comparable_with<_Tp, _Up> &&
+  _LIBCUDACXX_FRAGMENT(_Totally_ordered_with_, _Tp, _Up);;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_TOTALLY_ORDERED_H
diff --git a/include/cuda/std/detail/libcxx/include/__type_traits/common_reference.h b/include/cuda/std/detail/libcxx/include/__type_traits/common_reference.h
new file mode 100644
index 0000000000..6c6da536bf
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__type_traits/common_reference.h
@@ -0,0 +1,188 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H
+#define _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#include <utility>
+#else
+#include "copy_cv.h"
+#include "copy_cvref.h"
+#endif // __cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// common_reference
+#if _LIBCUDACXX_STD_VER > 11
+
+template <class...> 
+using _Exists = void;
+
+// Let COND_RES(X, Y) be:
+template <class _Xp, class _Yp>
+using __cond_res =
+    decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()());
+
+// Let `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes the same type as `U`
+// with the addition of `A`'s cv and reference qualifiers, for a non-reference cv-unqualified type
+// `U`.
+// [Note: `XREF(A)` is `__xref<A>::template __apply`]
+template <class _Tp>
+struct __xref {
+  template<class _Up>
+  using __apply = __copy_cvref_t<_Tp, _Up>;
+};
+
+// Given types A and B, let X be remove_reference_t<A>, let Y be remove_reference_t<B>,
+// and let COMMON-REF(A, B) be:
+template<class _Ap, class _Bp, class _Xp = remove_reference_t<_Ap>, class _Yp = remove_reference_t<_Bp>, class = void>
+struct __common_ref;
+
+template<class _Xp, class _Yp>
+using __common_ref_t = typename __common_ref<_Xp, _Yp>::__type;
+
+template<class _Xp, class _Yp>
+using __cv_cond_res = __cond_res<__copy_cv_t<_Xp, _Yp>&, __copy_cv_t<_Yp, _Xp>&>;
+
+
+//    If A and B are both lvalue reference types, COMMON-REF(A, B) is
+//    COND-RES(COPYCV(X, Y)&, COPYCV(Y, X)&) if that type exists and is a reference type.
+template<class _Ap, class _Bp, class _Xp, class _Yp>
+struct __common_ref<_Ap&, _Bp&, _Xp, _Yp, _Exists<__cv_cond_res<_Xp, _Yp>, 
+    _CUDA_VSTD::enable_if_t<is_reference_v<__cv_cond_res<_Xp, _Yp>>>>>
+{
+    using __type = __cv_cond_res<_Xp, _Yp>;
+};
+
+//    Otherwise, let C be remove_reference_t<COMMON-REF(X&, Y&)>&&. ...
+template <class _Xp, class _Yp>
+using __common_ref_C = remove_reference_t<__common_ref_t<_Xp&, _Yp&>>&&;
+
+
+//    .... If A and B are both rvalue reference types, C is well-formed, and
+//    is_convertible_v<A, C> && is_convertible_v<B, C> is true, then COMMON-REF(A, B) is C.
+template<class _Ap, class _Bp, class _Xp, class _Yp>
+struct __common_ref<_Ap&&, _Bp&&, _Xp, _Yp, _Exists<__common_ref_C<_Xp, _Yp>,
+    _CUDA_VSTD::enable_if_t<is_convertible_v<_Ap&&, __common_ref_C<_Xp, _Yp>> 
+                         && is_convertible_v<_Bp&&, __common_ref_C<_Xp, _Yp>>>>>
+{
+    using __type = __common_ref_C<_Xp, _Yp>;
+};
+
+//    Otherwise, let D be COMMON-REF(const X&, Y&). ...
+template <class _Tp, class _Up>
+using __common_ref_D = __common_ref_t<const _Tp&, _Up&>;
+
+//    ... If A is an rvalue reference and B is an lvalue reference and D is well-formed and
+//    is_convertible_v<A, D> is true, then COMMON-REF(A, B) is D.
+template<class _Ap, class _Bp, class _Xp, class _Yp>
+struct __common_ref<_Ap&&, _Bp&, _Xp, _Yp, _Exists<__common_ref_D<_Xp, _Yp>,
+    _CUDA_VSTD::enable_if_t<is_convertible_v<_Ap&&, __common_ref_D<_Xp, _Yp>>>>>
+{
+    using __type = __common_ref_D<_Xp, _Yp>;
+};
+
+//    Otherwise, if A is an lvalue reference and B is an rvalue reference, then
+//    COMMON-REF(A, B) is COMMON-REF(B, A).
+template<class _Ap, class _Bp, class _Xp, class _Yp>
+struct __common_ref<_Ap&, _Bp&&, _Xp, _Yp, _Exists<__common_ref_D<_Yp, _Xp>,
+    _CUDA_VSTD::enable_if_t<is_convertible_v<_Bp&&, __common_ref_D<_Yp, _Xp>>>>>
+    : __common_ref<_Bp&&, _Ap&> {};
+//    Otherwise, COMMON-REF(A, B) is ill-formed.
+template<class _Ap, class _Bp, class _Xp, class _Yp, class>
+struct __common_ref {};
+
+// Note C: For the common_reference trait applied to a parameter pack [...]
+
+template <class...>
+struct common_reference;
+
+template <class... _Types>
+using common_reference_t = typename common_reference<_Types...>::type;
+
+// bullet 1 - sizeof...(T) == 0
+template<>
+struct common_reference<> {};
+
+// bullet 2 - sizeof...(T) == 1
+template <class _Tp>
+struct common_reference<_Tp>
+{
+    using type = _Tp;
+};
+
+// bullet 3 - sizeof...(T) == 2
+template <class _Tp, class _Up, class = void> struct __common_reference_sub_bullet3;
+template <class _Tp, class _Up, class = void> struct __common_reference_sub_bullet2 
+    : __common_reference_sub_bullet3<_Tp, _Up> {};
+template <class _Tp, class _Up, class = void> struct __common_reference_sub_bullet1 
+    : __common_reference_sub_bullet2<_Tp, _Up> {};
+
+// sub-bullet 1 - If T1 and T2 are reference types and COMMON-REF(T1, T2) is well-formed, then
+// the member typedef `type` denotes that type.
+template <class _Tp, class _Up> struct common_reference<_Tp, _Up> : __common_reference_sub_bullet1<_Tp, _Up> {};
+
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet1<_Tp, _Up, _Exists<__common_ref_t<_Tp, _Up>, 
+    _CUDA_VSTD::enable_if_t<is_reference_v<_Tp> && is_reference_v<_Up>>>>
+{
+    using type = __common_ref_t<_Tp, _Up>;
+};
+
+// sub-bullet 2 - Otherwise, if basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>, XREF(T1), XREF(T2)>::type
+// is well-formed, then the member typedef `type` denotes that type.
+template <class, class, template <class> class, template <class> class> struct basic_common_reference {};
+
+template <class _Tp, class _Up>
+using __basic_common_reference_t = typename basic_common_reference<
+    remove_cvref_t<_Tp>, remove_cvref_t<_Up>,
+    __xref<_Tp>::template __apply, __xref<_Up>::template __apply>::type;
+
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet2<_Tp, _Up, _Exists<__basic_common_reference_t<_Tp, _Up>>>
+{
+    using type = __basic_common_reference_t<_Tp, _Up>;
+};
+
+// sub-bullet 3 - Otherwise, if COND-RES(T1, T2) is well-formed,
+// then the member typedef `type` denotes that type.
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet3<_Tp, _Up, _Exists<__cond_res<_Tp, _Up>>>
+{
+    using type = __cond_res<_Tp, _Up>;
+};
+
+
+// sub-bullet 4 & 5 - Otherwise, if common_type_t<T1, T2> is well-formed,
+//                    then the member typedef `type` denotes that type.
+//                  - Otherwise, there shall be no member `type`.
+template <class _Tp, class _Up, class> struct __common_reference_sub_bullet3 : common_type<_Tp, _Up> {};
+
+// bullet 4 - If there is such a type `C`, the member typedef type shall denote the same type, if
+//            any, as `common_reference_t<C, Rest...>`.
+template <class _Tp, class _Up, class _Vp, class... _Rest>
+struct common_reference<_Tp, _Up, _Vp, _Exists<common_reference_t<_Tp, _Up>>, _Rest...>
+    : common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...>
+{};
+
+// bullet 5 - Otherwise, there shall be no member `type`.
+template <class...> struct common_reference {};
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H
\ No newline at end of file
diff --git a/include/cuda/std/detail/libcxx/include/__type_traits/copy_cv.h b/include/cuda/std/detail/libcxx/include/__type_traits/copy_cv.h
new file mode 100644
index 0000000000..4849864824
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__type_traits/copy_cv.h
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H
+#define _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#endif // __cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Let COPYCV(FROM, TO) be an alias for type TO with the addition of FROM's
+// top-level cv-qualifiers.
+template <class _From, class _To>
+struct __copy_cv
+{
+    using type = _To;
+};
+
+template <class _From, class _To>
+struct __copy_cv<const _From, _To>
+{
+    using type = typename add_const<_To>::type;
+};
+
+template <class _From, class _To>
+struct __copy_cv<volatile _From, _To>
+{
+    using type = typename add_volatile<_To>::type;
+};
+
+template <class _From, class _To>
+struct __copy_cv<const volatile _From, _To>
+{
+    using type = typename add_cv<_To>::type;
+};
+
+template <class _From, class _To>
+using __copy_cv_t = typename __copy_cv<_From, _To>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H
diff --git a/include/cuda/std/detail/libcxx/include/__type_traits/copy_cvref.h b/include/cuda/std/detail/libcxx/include/__type_traits/copy_cvref.h
new file mode 100644
index 0000000000..1e214a616d
--- /dev/null
+++ b/include/cuda/std/detail/libcxx/include/__type_traits/copy_cvref.h
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H
+#define _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <type_traits>
+#else
+#include "copy_cv.h"
+#endif // __cuda_std__
+
+#if !defined(_LIBCUDACXX_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _From, class _To>
+struct __copy_cvref
+{
+    using type = __copy_cv_t<_From, _To>;
+};
+
+template <class _From, class _To>
+struct __copy_cvref<_From&, _To>
+{
+    using type = typename add_lvalue_reference<__copy_cv_t<_From, _To> >::type;
+};
+
+template <class _From, class _To>
+struct __copy_cvref<_From&&, _To>
+{
+    using type = typename add_rvalue_reference<__copy_cv_t<_From, _To> >::type;
+};
+
+template <class _From, class _To>
+using __copy_cvref_t = typename __copy_cvref<_From, _To>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H
diff --git a/include/cuda/std/detail/libcxx/include/type_traits b/include/cuda/std/detail/libcxx/include/type_traits
index 44f7c654a7..a271ccf6d8 100644
--- a/include/cuda/std/detail/libcxx/include/type_traits
+++ b/include/cuda/std/detail/libcxx/include/type_traits
@@ -4853,6 +4853,12 @@ bool __libcpp_is_constant_evaluated() _NOEXCEPT { return false; }
 template <class _CharT>
 using _IsCharLikeType = _And<is_standard_layout<_CharT>, is_trivial<_CharT> >;
 
+template<class _Tp>
+using __make_const_lvalue_ref = const typename remove_reference<_Tp>::type&;
+
+template<bool _Const, class _Tp>
+using __maybe_const = typename conditional<_Const, const _Tp, _Tp>::type;
+
 _LIBCUDACXX_END_NAMESPACE_STD
 
 #if _LIBCUDACXX_STD_VER > 11
diff --git a/include/cuda/std/detail/libcxx/include/utility b/include/cuda/std/detail/libcxx/include/utility
index e9c9606249..d8cce9df7e 100644
--- a/include/cuda/std/detail/libcxx/include/utility
+++ b/include/cuda/std/detail/libcxx/include/utility
@@ -936,7 +936,7 @@ template<class... _Tp>
 
 #if _LIBCUDACXX_STD_VER > 11
 template<class _T1, class _T2 = _T1>
-inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
 _T1 exchange(_T1& __obj, _T2 && __new_value)
 {
     _T1 __old_value = _CUDA_VSTD::move(__obj);