[libcxx] Adds [concept.same]

[cjdb]

Summary

Adds std::same_as to libc++. Since there aren't clang-format rules for requires-expressions, I'll need to disable the formatter in certain areas.

[cjdb]

Added a check for constness and removed some Unicode zero-width joiners.

[miscco]

libcxx/include/concepts

149

You are missing the uglification of all namens throughout the code. Mind not in Tests.

T -> _Tp

[miscco]

This looks already quite good.

There are some pecularities of standard implementations that need to be considered. I started with the easy parts recently here

https://github.com/miscco/llvm-project/tree/concepts_wip

libcxx/include/concepts

150

Thinking about it more, this will not work with other compilers such as MSVC. You should seither check the Compiler aka #ifdef clang or the existence of the keyword

libcxx/test/std/concepts/lang/same_as.pass.cpp

9

This test is only valid in C++20 so you should add that

// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17

12

Usually there is a comment about what is tested here

template<class T, class U>
concept same_as;

[miscco]

libcxx/include/concepts

150

As the code was not displayed properly

template <class _Tp, class _Up>
concept __same_as_impl =
#ifdef __clang__
    __is_same(_Tp, _Up);
#else
    _VSTD::is_same_v<_Tp, _Up>;
#endif

[CaseyCarter]

Missing a bunch of "Add a new header" changes (https://github.com/llvm/llvm-project/blob/master/libcxx/NOTES.TXT#L19-L29).

libcxx/include/concepts

9

Shouldn't this line have the same length as line 2?

140

#pragma GCC system header? https://github.com/llvm/llvm-project/blob/master/libcxx/include/any#L91-L93

146

Should this also guard with defined(__cpp_concepts) && __cpp_concepts >= 201811L? There are a great many compiler (version)s with C++20 mode that don't implement concepts - I assume libc++ wants to continue supporting them.

150

Clang has supported __is_same since roughly clang 3. I didn't remember precisely how far back libc++ supports, but it's not that far - so assuming __is_same when __clang__ is fine. GCC since version 6 supports __is_same_as with the same semantics. (MSVC has none of the above, but std::is_same_v is one of the type traits we recognize and implement directly in the compiler front end, so it's ideal to simply use is_same_v with MSVC.)

libcxx/test/std/concepts/lang/same_as.pass.cpp

82

I think we can trust a C++20 compiler to implement C++11 correctly and accept >> here without the space ;)

154

libc++ tests always use int main(int, char**) { (something something freestanding - I don't recall the details)

190

There's tons of coverage here for class types and reference types. What about void, function types, pointers, arrays, pointers-to-members? (I don't know about clang/libc++, but the MSVC STL tests for type traits tend to _be_ the tests for compiler intrinsics used to implement those traits, so we consequently cover everything under the sun.)

191

libc++ tests also always explicitly return 0. (Ditto freestanding yada yada)

[miscco]

For what its worth, I found some time today to cleanup what I had already done with @CaseyCarter old implementation D49118 (common_type and common_reference were missing).

I havent yet implemented swap as that should be handled consistently with the other CPOs when implementing ranges.

Feel free to salvage as much as you like

https://github.com/miscco/llvm-project/tree/concepts_wip

[zoecarver]

libcxx/include/concepts

150

You can also use _IsSame which should pick the best possible definition for you.

[cjdb]

libcxx/include/concepts

146

Agreed.

149

Fixed.

libcxx/test/std/concepts/lang/same_as.pass.cpp

82

Agreed. *Stares intensely at clang-format*

190

• void (/)
• function types (/)
• pointers (/)
• arrays (/)
• pointers-to-members (/)
• pointers-to-member functions (/)

[miscco]

libcxx/test/std/concepts/lang/same_as.pass.cpp

47

Out of curiosity should that be T1 t1; and below T2 t2;

189

Nitpick, if we go for all the different qualifiers/references there should be a test for volatile to

    // Checks std::same_as<volatile T, volatile T> is true
    CheckSameAs<std::add_volatile>();
`

230

Same as above volatile is missing

[CaseyCarter]

LGTM. I'll resign rather than approving so the "real" approvers won't be confused and never look at this.

[cjdb]

libcxx/test/std/concepts/lang/same_as.pass.cpp

47

It probably could be, but it doesn't make a difference for this test.

[cjdb]

Rebased according to 08682dcc863.

[EricWF]

LGTM.

I have some concerns with how we harden our concepts,
but these can be addressed in follow up commits.

libcxx/include/concepts

138

I think __version should be included here too.

162

I think we're missing a _LIBCPP_POP_MACROS?

[cjdb]

Applies changes to comments made by @EricWF and @miscco.

[EricWF]

Committed as 601f7631827ae6ac08117a282c83a62b67dedf48

libcxx/CREDITS.TXT

 E: [e-mail]
 E: [e-mail]
 D: C++14 support, patches and bug fixes.
 
 N: Jonathan B Coe
 E: [e-mail]
 D: Implementation of propagate_const.
 
+N: Christopher Di Bella
+E: [e-mail]
+E: [e-mail]
+D: Library concepts.
+
 N: Glen Joseph Fernandes
 E: [e-mail]
 D: Implementation of to_address.
 
 N: Eric Fiselier
 E: [e-mail]
 D: LFTS support, patches and bug fixes.
 

libcxx/include/CMakeLists.txt

set(files
   ciso646
   climits
   clocale
   cmath
   codecvt
   compare
   complex
   complex.h
+  concepts
   condition_variable
   csetjmp
   csignal
   cstdarg
   cstdbool
   cstddef
   cstdint
   cstdio

libcxx/include/concepts

+// -*- C++ -*-
+//===-------------------------- concepts ----------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_CONCEPTS
+#define _LIBCPP_CONCEPTS
+
+/*
+    concepts synopsis
+namespace std {
+  // [concepts.lang], language-related concepts
+  // [concept.same], concept same_as
+  template<class T, class U>
+    concept same_as = see below;
+
+  // [concept.derived], concept derived_from
+  template<class Derived, class Base>
+    concept derived_from = see below;
+
+  // [concept.convertible], concept convertible_to
+  template<class From, class To>
+    concept convertible_to = see below;
+
+  // [concept.commonref], concept common_reference_with
+  template<class T, class U>
+    concept common_reference_with = see below;
+
+  // [concept.common], concept common_with
+  template<class T, class U>
+    concept common_with = see below;
+
+  // [concepts.arithmetic], arithmetic concepts
+  template<class T>
+    concept integral = see below;
+  template<class T>
+    concept signed_integral = see below;
+  template<class T>
+    concept unsigned_integral = see below;
+  template<class T>
+    concept floating_point = see below;
+
+  // [concept.assignable], concept assignable_from
+  template<class LHS, class RHS>
+    concept assignable_from = see below;
+
+  // [concept.swappable], concept swappable
+  namespace ranges {
+    inline namespace unspecified {
+      inline constexpr unspecified swap = unspecified;
+    }
+  }
+  template<class T>
+    concept swappable = see below;
+  template<class T, class U>
+    concept swappable_with = see below;
+
+  // [concept.destructible], concept destructible
+  template<class T>
+    concept destructible = see below;
+
+  // [concept.constructible], concept constructible_from
+  template<class T, class... Args>
+    concept constructible_from = see below;
+
+  // [concept.defaultconstructible], concept default_constructible
+  template<class T>
+    concept default_constructible = see below;
+
+  // [concept.moveconstructible], concept move_constructible
+  template<class T>
+    concept move_constructible = see below;
+
+  // [concept.copyconstructible], concept copy_constructible
+  template<class T>
+    concept copy_constructible = see below;
+
+  // [concepts.compare], comparison concepts
+  // [concept.boolean], concept boolean
+  template<class B>
+    concept boolean = see below;
+
+  // [concept.equalitycomparable], concept equality_comparable
+  template<class T>
+    concept equality_comparable = see below;
+  template<class T, class U>
+    concept equality_comparable_with = see below;
+
+  // [concept.totallyordered], concept totally_ordered
+  template<class T>
+    concept totally_ordered = see below;
+  template<class T, class U>
+    concept totally_ordered_with = see below;
+
+  // [concepts.object], object concepts
+  template<class T>
+    concept movable = see below;
+  template<class T>
+    concept copyable = see below;
+  template<class T>
+    concept semiregular = see below;
+  template<class T>
+    concept regular = see below;
+
+  // [concepts.callable], callable concepts
+  // [concept.invocable], concept invocable
+  template<class F, class... Args>
+    concept invocable = see below;
+
+  // [concept.regularinvocable], concept regular_invocable
+  template<class F, class... Args>
+    concept regular_invocable = see below;
+
+  // [concept.predicate], concept predicate
+  template<class F, class... Args>
+    concept predicate = see below;
+
+  // [concept.relation], concept relation
+  template<class R, class T, class U>
+    concept relation = see below;
+
+  // [concept.equiv], concept equivalence_relation
+  template<class R, class T, class U>
+    concept equivalence_relation = see below;
+
+  // [concept.strictweakorder], concept strict_weak_order
+  template<class R, class T, class U>
+    concept strict_weak_order = see below;
+}
+
+*/
+
+#include <__config>
+#include <type_traits>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+
+// [concept.same]
+
+template<class _Tp, class _Up>
+concept __same_as_impl = _VSTD::_IsSame<_Tp, _Up>::value;
+
+template<class _Tp, class _Up>
+concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
+
+#endif //_LIBCPP_STD_VER > 17 && defined(__cpp_concepts) && __cpp_concepts >= 201811L
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_CONCEPTS

libcxx/include/module.modulemap

module std [system] {
   module compare {
     header "compare"
     export *
   }
   module complex {
     header "complex"
     export *
   }
+  module concepts {
+    header "concepts"
+    export *
+  }
   module condition_variable {
     header "condition_variable"
     export *
   }
   module deque {
     header "deque"
     export initializer_list
     export *

libcxx/test/libcxx/double_include.sh.cpp

 #include <ciso646>
 #include <climits>
 #include <clocale>
 #include <cmath>
 #include <codecvt>
 #include <compare>
 #include <complex>
 #include <complex.h>
+#include <concepts>
 #include <condition_variable>
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>

libcxx/test/std/concepts/lang/same_as.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// template<class T, class U>
+// concept same_as;
+
+#include <concepts>
+#include <type_traits>
+
+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>
+void CheckSameAs() {
+  static_assert(
+      std::same_as<typename Modifier<int>::type, typename Modifier<int>::type>);
+  static_assert(
+      std::same_as<typename Modifier<S1>::type, typename Modifier<S1>::type>);
+  static_assert(
+      std::same_as<typename Modifier<S2>::type, typename Modifier<S2>::type>);
+  static_assert(
+      std::same_as<typename Modifier<S3>::type, typename Modifier<S3>::type>);
+  static_assert(
+      std::same_as<typename Modifier<S4>::type, typename Modifier<S4>::type>);
+  static_assert(
+      std::same_as<typename Modifier<S5>::type, typename Modifier<S5>::type>);
+  static_assert(
+      std::same_as<typename Modifier<C1>::type, typename Modifier<C1>::type>);
+  static_assert(
+      std::same_as<typename Modifier<C2>::type, typename Modifier<C2>::type>);
+  static_assert(
+      std::same_as<typename Modifier<C3>::type, typename Modifier<C3>::type>);
+  static_assert(std::same_as<typename Modifier<C4<int> >::type,
+                             typename Modifier<C4<int> >::type>);
+  static_assert(std::same_as<typename Modifier<C4<int&> >::type,
+                             typename Modifier<C4<int&> >::type>);
+  static_assert(std::same_as<typename Modifier<C4<int&&> >::type,
+                             typename Modifier<C4<int&&> >::type>);
+  static_assert(std::same_as<typename Modifier<C5<int> >::type,
+                             typename Modifier<C5<int> >::type>);
+  static_assert(std::same_as<typename Modifier<C5<int&> >::type,
+                             typename Modifier<C5<int&> >::type>);
+  static_assert(std::same_as<typename Modifier<C5<int&&> >::type,
+                             typename Modifier<C5<int&&> >::type>);
+  static_assert(std::same_as<typename Modifier<C6<int> >::type,
+                             typename Modifier<C6<int> >::type>);
+  static_assert(std::same_as<typename Modifier<C6<int&> >::type,
+                             typename Modifier<C6<int&> >::type>);
+  static_assert(std::same_as<typename Modifier<C6<int&&> >::type,
+                             typename Modifier<C6<int&&> >::type>);
+
+  static_assert(std::same_as<typename Modifier<void>::type,
+                             typename Modifier<void>::type>);
+}
+
+template <template <typename> class Modifier1,
+          template <typename> class Modifier2>
+void CheckNotSameAs() {
+  static_assert(!std::same_as<typename Modifier1<int>::type,
+                              typename Modifier2<int>::type>);
+  static_assert(!std::same_as<typename Modifier1<S1>::type,
+                              typename Modifier2<S1>::type>);
+  static_assert(!std::same_as<typename Modifier1<S2>::type,
+                              typename Modifier2<S2>::type>);
+  static_assert(!std::same_as<typename Modifier1<S3>::type,
+                              typename Modifier2<S3>::type>);
+  static_assert(!std::same_as<typename Modifier1<S4>::type,
+                              typename Modifier2<S4>::type>);
+  static_assert(!std::same_as<typename Modifier1<S5>::type,
+                              typename Modifier2<S5>::type>);
+  static_assert(!std::same_as<typename Modifier1<C1>::type,
+                              typename Modifier2<C1>::type>);
+  static_assert(!std::same_as<typename Modifier1<C2>::type,
+                              typename Modifier2<C2>::type>);
+  static_assert(!std::same_as<typename Modifier1<C3>::type,
+                              typename Modifier2<C3>::type>);
+  static_assert(!std::same_as<typename Modifier1<C4<int> >::type,
+                              typename Modifier2<C4<int> >::type>);
+  static_assert(!std::same_as<typename Modifier1<C4<int&> >::type,
+                              typename Modifier2<C4<int&> >::type>);
+  static_assert(!std::same_as<typename Modifier1<C4<int&&> >::type,
+                              typename Modifier2<C4<int&&> >::type>);
+  static_assert(!std::same_as<typename Modifier1<C5<int> >::type,
+                              typename Modifier2<C5<int> >::type>);
+  static_assert(!std::same_as<typename Modifier1<C5<int&> >::type,
+                              typename Modifier2<C5<int&> >::type>);
+  static_assert(!std::same_as<typename Modifier1<C5<int&&> >::type,
+                              typename Modifier2<C5<int&&> >::type>);
+  static_assert(!std::same_as<typename Modifier1<C6<int> >::type,
+                              typename Modifier2<C6<int> >::type>);
+  static_assert(!std::same_as<typename Modifier1<C6<int&> >::type,
+                              typename Modifier2<C6<int&> >::type>);
+  static_assert(!std::same_as<typename Modifier1<C6<int&&> >::type,
+                              typename Modifier2<C6<int&&> >::type>);
+}
+
+// Checks subsumption works as intended
+template <class T, class U>
+requires std::same_as<T, U> void SubsumptionTest();
+
+// clang-format off
+template <class T, class U>
+requires std::same_as<U, T> && true // NOLINT(readability-simplify-boolean-expr)
+int SubsumptionTest();
+// clang-format on
+
+static_assert(std::same_as<int, decltype(SubsumptionTest<int, int>())>);
+static_assert(std::same_as<int, decltype(SubsumptionTest<void, void>())>);
+static_assert(
+    std::same_as<int, decltype(SubsumptionTest<int (*)(), int (*)()>())>);
+static_assert(
+    std::same_as<
+        int, decltype(SubsumptionTest<double (&)(int), double (&)(int)>())>);
+static_assert(
+    std::same_as<int, decltype(SubsumptionTest<int S2::*, int S2::*>())>);
+static_assert(
+    std::same_as<int,
+                 decltype(SubsumptionTest<int& (S2::*)(), int& (S2::*)()>())>);
+
+int main(int, char**) {
+  { // Checks std::same_as<T, T> is true
+    CheckSameAs();
+
+    // Checks std::same_as<T&, T&> is true
+    CheckSameAs<std::add_lvalue_reference>();
+
+    // Checks std::same_as<T&&, T&&> is true
+    CheckSameAs<std::add_rvalue_reference>();
+
+    // Checks std::same_as<const T, const T> is true
+    CheckSameAs<std::add_const>();
+
+    // Checks std::same_as<volatile T, volatile T> is true
+    CheckSameAs<std::add_volatile>();
+
+    // Checks std::same_as<const volatile T, const volatile T> is true
+    CheckSameAs<std::add_cv>();
+
+    // Checks std::same_as<T*, T*> is true
+    CheckSameAs<std::add_pointer>();
+
+    // Checks concrete types are identical
+    static_assert(std::same_as<void, void>);
+
+    using Void = void;
+    static_assert(std::same_as<void, Void>);
+
+    static_assert(std::same_as<int[1], int[1]>);
+    static_assert(std::same_as<int[2], int[2]>);
+
+    static_assert(std::same_as<int (*)(), int (*)()>);
+    static_assert(std::same_as<void (&)(), void (&)()>);
+    static_assert(std::same_as<S1& (*)(S1), S1& (*)(S1)>);
+    static_assert(std::same_as<C1& (&)(S1, int), C1& (&)(S1, int)>);
+
+    static_assert(std::same_as<int S2::*, int S2::*>);
+    static_assert(std::same_as<double S2::*, double S2::*>);
+
+    static_assert(std::same_as<int& (S2::*)(), int& (S2::*)()>);
+    static_assert(std::same_as<double& (S2::*)(int), double& (S2::*)(int)>);
+  }
+
+  { // Checks that `T` and `T&` are distinct types
+    CheckNotSameAs<identity, std::add_lvalue_reference>();
+    CheckNotSameAs<std::add_lvalue_reference, identity>();
+
+    // Checks that `T` and `T&&` are distinct types
+    CheckNotSameAs<identity, std::add_rvalue_reference>();
+    CheckNotSameAs<std::add_rvalue_reference, identity>();
+
+    // Checks that `T` and `const T` are distinct types
+    CheckNotSameAs<identity, std::add_const>();
+    CheckNotSameAs<std::add_const, identity>();
+
+    // Checks that `T` and `volatile T` are distinct types
+    CheckNotSameAs<identity, std::add_volatile>();
+    CheckNotSameAs<std::add_volatile, identity>();
+
+    // Checks that `T` and `const volatile T` are distinct types
+    CheckNotSameAs<identity, std::add_cv>();
+    CheckNotSameAs<std::add_cv, identity>();
+
+    // Checks that `const T` and `volatile T` are distinct types
+    CheckNotSameAs<std::add_const, std::add_volatile>();
+    CheckNotSameAs<std::add_volatile, std::add_const>();
+
+    // Checks that `const T` and `const volatile T` are distinct types
+    CheckNotSameAs<std::add_const, std::add_cv>();
+    CheckNotSameAs<std::add_cv, std::add_const>();
+
+    // Checks that `volatile T` and `const volatile T` are distinct types
+    CheckNotSameAs<std::add_volatile, std::add_cv>();
+    CheckNotSameAs<std::add_cv, std::add_volatile>();
+
+    // Checks `T&` and `T&&` are distinct types
+    CheckNotSameAs<std::add_lvalue_reference, std::add_rvalue_reference>();
+    CheckNotSameAs<std::add_rvalue_reference, std::add_lvalue_reference>();
+  }
+
+  { // Checks different type names are distinct types
+    static_assert(!std::same_as<S1, C1>);
+    static_assert(!std::same_as<C4<int>, C5<int> >);
+    static_assert(!std::same_as<C4<int>, C5<int> >);
+    static_assert(!std::same_as<C5<int, double>, C5<double, int> >);
+
+    static_assert(!std::same_as<int&, const int&>);
+    static_assert(!std::same_as<int&, volatile int&>);
+    static_assert(!std::same_as<int&, const volatile int&>);
+
+    static_assert(!std::same_as<int&&, const int&>);
+    static_assert(!std::same_as<int&&, volatile int&>);
+    static_assert(!std::same_as<int&&, const volatile int&>);
+
+    static_assert(!std::same_as<int&, const int&&>);
+    static_assert(!std::same_as<int&, volatile int&&>);
+    static_assert(!std::same_as<int&, const volatile int&&>);
+
+    static_assert(!std::same_as<int&&, const int&&>);
+    static_assert(!std::same_as<int&&, volatile int&&>);
+    static_assert(!std::same_as<int&&, const volatile int&&>);
+
+    static_assert(!std::same_as<void, int>);
+
+    static_assert(!std::same_as<int[1], int[2]>);
+    static_assert(!std::same_as<double[1], int[2]>);
+
+    static_assert(!std::same_as<int* (*)(), const int* (*)()>);
+    static_assert(!std::same_as<void (&)(), void (&)(S1)>);
+    static_assert(!std::same_as<S1 (*)(S1), S1& (*)(S1)>);
+    static_assert(!std::same_as<C3 (&)(int), C1& (&)(S1, int)>);
+
+    static_assert(!std::same_as<int S2::*, double S2::*>);
+
+    static_assert(!std::same_as<int& (S2::*)(), double& (S2::*)(int)>);
+  }
+
+  return 0;
+}