[libc++] P0898R3 2 of 12: Implement <concepts> header

[CaseyCarter]

Summary

Piece number two contains the header, a bunch of "add a new header" changes, and LIT config to grok tests that need concepts (Thanks to @EricWF's similar handling for coroutines which I copied shamelessly).

No tests yet, but fear not - there are 10 pieces yet to come ;)

[CaseyCarter]

include/concepts

194

I suppose it would have been a good idea to fix this before submitting the patch for review - but it's too late now.

The issue here is that ConvertibleTo as specified rejects all conversions from array and function types. While this makes sense on the one hand - there are no expressions of array or function type from which to convert - it is a difference relative to is_convertible that I don't think any of the LEWG/LWG design discussions considered.

This conditional should be either removed, or the condition "flipped" so the concept definition agrees with the working draft. The affected test cases need to be conditional as well.

[• Quuxplusone]

include/concepts

176

Peanut gallery asks: From lines 166-171 it looks awfully like __same_impl<_Tp, _Up> is true if and only if __same_impl<_Up, _Tp> is true. So why bother instantiating both templates?

281

Peanut gallery notices the lack of Constructible<_Tp, const _Tp&&> here, and assumes it's intentional?

296

Peanut gallery asks: Am I correct that the instances of ConvertibleTo<..., bool> here could (according to the WD) be replaced with -> bool? Am I correct that the instances of Same<..., bool> here could eventually be replaced with -> Same<bool> once they fix that issue you wrote a paper about?

I assume they're written like this for portability reasons.

380

Does this need a _VSTD:: for ADL reasons? (There's one in <tuple> that does use _VSTD::; there's two in <variant> that don't.)

395

I'm fairly confident that const remove_reference_t<_Tp>& is just const _Tp&.

[CaseyCarter]

include/concepts

176

This is the library implementation of the ["Same<T, U> subsumes Same<U, T>" requirement](http://eel.is/c++draft/concept.same#1).

281

Yes: Constructible<T, Args..> is equal to is_constructible_v<T, Args...> which is true iff the declaration T t(declval<Args>()...); is valid. Since decltype(declval<T>()) is add_rvalue_reference_t<T>, Constructible<_Tp, const _Tp> is equal to Constructible<_Tp, const _Tp&&>.

Admittedly the compiler doesn't know that - the subsumption rules don't know how declval is implemented - but no one has yet presented a use case where it would be helpful. If and when that happens, we can consider adding more terms to the concepts.

296

ConvertibleTo requires both implicit and explicit conversions to be valid and have equal results - so it's stronger than is_convertible and therefore the core language's notion of implicit convertibility. Consequently -> bool would not be equivalent.

Yes, P1084 will let us simplify all of these horrible nested requirements that duplicate the expressions. E; requires Concept<decltype(E), Args..>; will become { E } -> Concept<Args...>;.

380

Yes it does. Despite that the function name is ugly and a user can't hijack it, ADL will do crazy things like instantiating T when passed T* to determine T's associated namespaces.

395

Not when _Tp is a reference type: https://godbolt.org/g/Q2Hon8.

[• Quuxplusone]

include/concepts

176

Ah, so this and tangentially line 280 are both about fiddling with "subsumption." Admittedly I don't know how the compiler side is implemented, but it seems too bad that the library has to do double the work (even at this leafy of a level) just to deal with subsumption, which AIUI is required in order to properly order competing template specializations (a situation that is(?) unlikely to come up in the average end-user's code). :/
Anyway, carry on.

395

Ah, right, because of the const. Never mind!

[CaseyCarter]

Qualify call to __invoke_constexpr in the definition of the Invocable concept.

[CaseyCarter]

include/concepts

152

I've just realized I failed to update <version> with the feature test macro value. Does libc++ have a plan yet for how to handle the feature test macros? Should I #define it in <version> and include that here?

I suspect we should rename __config to <version> and define all feature test macros therein.

176

Ideally, Same would be implemented with an intrinsic that tells the compiler to ignore the parameter mappings (http://eel.is/c++draft/temp.constr.atomic#2) when it checks the atomic constraints defined in this concept for equivalence. Or better yet, we could expose that feature in the language - say with a context-sensitive keyword concept symmetric Same - that could be applied to any two-type concept. There are quite a few symmetric concepts that could benefit similarly - Common, CommonReference, all of the FooWith concepts - for which we don't require subsumption because evaluating them is significantly more expensive than Same.

CMakeLists.txt

 # Hide all inline function definitions which have not explicitly been marked
 # visible. This prevents new definitions for inline functions from appearing in
 # the dylib when get ODR used by another function.
 add_compile_flags_if_supported(-fvisibility-inlines-hidden)
 
 if (LIBCXX_CONFIGURE_IDE)
   # This simply allows IDE to process <experimental/coroutine>
   add_compile_flags_if_supported(-fcoroutines-ts)
+  # This (presumably) allows IDE to process <concepts>
+  add_compile_flags_if_supported(-fconcepts)
 endif()
 
 # Let the library headers know they are currently being used to build the
 # library.
 add_definitions(-D_LIBCPP_BUILDING_LIBRARY)
 
 if (NOT LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS)
   add_definitions(-D_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)

include/CMakeLists.txt

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

include/__config

 #define _LIBCPP_NORETURN __attribute__((noreturn))
 
 #if _GNUC_VER >= 407
 #define _LIBCPP_UNDERLYING_TYPE(T) __underlying_type(T)
 #define _LIBCPP_IS_LITERAL(T) __is_literal_type(T)
 #define _LIBCPP_HAS_IS_FINAL
 #endif
 
+#if defined(__GNUC__) && _GNUC_VER >= 600
+#define _LIBCPP_HAS_IS_SAME_AS
+#endif
+
 #if defined(__GNUC__) && _GNUC_VER >= 403
 #define _LIBCPP_HAS_IS_BASE_OF
 #endif
 
 #if !__EXCEPTIONS
 #define _LIBCPP_NO_EXCEPTIONS
 #endif
 

 #if !__has_keyword(__is_aggregate) && (_GNUC_VER_NEW < 7001)
 #define _LIBCPP_HAS_NO_IS_AGGREGATE
 #endif
 
 #if !defined(__cpp_coroutines) || __cpp_coroutines < 201703L
 #define _LIBCPP_HAS_NO_COROUTINES
 #endif
 
+// Note that there is no feature test macro for Concepts in the current C++20
+// working draft. Some of the concepts working papers - but notably neither the
+// TS nor the final proposal which was partially merged into the WD - defined
+// __cpp_concepts to 201507L. This is the value that GCC currently defines when
+// support for the concepts TS is enabled with -fconcepts. We therefore use
+// __cpp_concepts to detect support, and speculate that C++20-compliant
+// compilers will define __cpp_concepts to at least 201707 - the date of the
+// Toronto WG21 meeting that incorporated Concepts into the WD.
+#if !defined(__cpp_concepts) || __cpp_concepts < 201507L
+#define _LIBCPP_HAS_NO_CONCEPTS
+#endif
+
 // FIXME: Correct this macro when either (A) a feature test macro for the
 // spaceship operator is provided, or (B) a compiler provides a complete
 // implementation.
 #define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
 
 // Decide whether to use availability macros.
 #if !defined(_LIBCPP_BUILDING_LIBRARY) &&                                      \
     !defined(_LIBCPP_DISABLE_AVAILABILITY) &&                                  \

include/concepts

+// -*- C++ -*-
+//===-------------------------- concepts ----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_CONCEPTS
+#define _LIBCPP_CONCEPTS
+
+/*
+    concepts synopsis
+
+// C++20
+
+namespace std
+{
+
+    // [concepts.lang], language-related concepts
+    // [concept.same], concept Same
+    template<class T, class U>
+      concept Same = see below;
+
+    // [concept.derivedfrom], concept DerivedFrom
+    template<class Derived, class Base>
+      concept DerivedFrom = see below;
+
+    // [concept.convertibleto], concept ConvertibleTo
+    template<class From, class To>
+      concept ConvertibleTo = see below;
+
+    // [concept.commonref], concept CommonReference
+    template<class T, class U>
+      concept CommonReference = see below;
+
+    // [concept.common], concept Common
+    template<class T, class U>
+      concept Common = see below;
+
+    // [concepts.integral], integral concepts
+    template<class T>
+      concept Integral = see below;
+    template<class T>
+      concept SignedIntegral = see below;
+    template<class T>
+      concept UnsignedIntegral = see below;
+
+    // [concept.assignable], concept Assignable
+    template<class LHS, class RHS>
+      concept Assignable = see below;
+
+    // [concept.swappable], concept Swappable
+    template<class T>
+      concept Swappable = see below;
+    template<class T, class U>
+      concept SwappableWith = see below;
+
+    // [concept.destructible], concept Destructible
+    template<class T>
+      concept Destructible = see below;
+
+    // [cooncept.constructible], concept Constructible
+    template<class T, class... Args>
+      concept Constructible = see below;
+
+    // [concept.defaultconstructible], concept DefaultConstructible
+    template<class T>
+      concept DefaultConstructible = see below;
+
+    // [concept.moveconstructible], concept MoveConstructible
+    template<class T>
+      concept MoveConstructible = see below;
+
+    // [concept.copyconstructible], concept CopyConstructible
+    template<class T>
+      concept CopyConstructible = see below;
+
+    // [concepts.compare], comparison concepts
+    // [concept.boolean], concept Boolean
+    template<class B>
+      concept Boolean = see below;
+
+    // [concept.equalitycomparable], concept EqualityComparable
+    template<class T>
+      concept EqualityComparable = see below;
+    template<class T, class U>
+      concept EqualityComparableWith = see below;
+
+    // [concept.stricttotallyordered], concept StrictTotallyOrdered
+    template<class T>
+      concept StrictTotallyOrdered = see below;
+    template<class T, class U>
+      concept StrictTotallyOrderedWith = 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 RegularInvocable
+    template<class F, class... Args>
+      concept RegularInvocable = 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.strictweakorder], concept StrictWeakOrder
+    template<class R, class T, class U>
+      concept StrictWeakOrder = see below;
+
+}
+
+*/
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#ifdef _LIBCPP_HAS_NO_CONCEPTS
+# if defined(_LIBCPP_WARNING)
+    _LIBCPP_WARNING("<concepts> cannot be used with this compiler")
+# else
+#   warning <concepts> cannot be used with this compiler
+# endif
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS) && _LIBCPP_STD_VER > 17
+#define __cpp_lib_concepts 201806L
+
+#if __cpp_concepts < 201707L
+#define _LIBCPP_CONCEPT_DECL concept bool
+#else
+#define _LIBCPP_CONCEPT_DECL concept
+#endif //  __cpp_concepts < 201707L
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef _LIBCPP_HAS_IS_SAME_AS
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL __same_impl = __is_same_as(_Tp, _Up);
+#else
+template <class, class>
+_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool __same_impl_ = false;
+template <class _Tp>
+_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool __same_impl_<_Tp, _Tp> = true;
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL __same_impl = __same_impl_<_Tp, _Up>;
+#endif // _LIBCPP_HAS_IS_SAME_AS
+
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL Same = __same_impl<_Tp, _Up> && __same_impl<_Up, _Tp>;
+
+template <class _Derived, class _Base>
+_LIBCPP_CONCEPT_DECL DerivedFrom =
+#ifdef _LIBCPP_HAS_IS_BASE_OF
+    __is_base_of(_Base, _Derived) &&
+#else
+    is_base_of_v<_Base, _Derived> &&
+#endif // _LIBCPP_HAS_IS_BASE_OF
+    is_convertible_v<const volatile _Derived*, const volatile _Base*>;
+
+template <class _From, class _To>
+_LIBCPP_CONCEPT_DECL ConvertibleTo =
+#if __has_feature(is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
+    __is_convertible_to(_From, _To) &&
+#else
+    is_convertible_v<_From, _To> &&
+#endif
+#if 0 // FIXME: File LWG issue
+    requires(_From (&_Fn)()) { static_cast<_To>(_Fn()); };
+#else
+    requires(add_rvalue_reference_t<_From> (&__fn)()) {
+        static_cast<_To>(__fn());
+    };
+#endif
+
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL CommonReference =
+    requires {
+        typename common_reference_t<_Tp, _Up>;
+        typename common_reference_t<_Up, _Tp>;
+    } &&
+    Same<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
+    ConvertibleTo<_Tp, common_reference_t<_Tp, _Up>> &&
+    ConvertibleTo<_Up, common_reference_t<_Tp, _Up>>;
+
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL Common =
+    requires {
+        typename common_type_t<_Tp, _Up>;
+        typename common_type_t<_Up, _Tp>;
+    } &&
+    Same<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
+    ConvertibleTo<_Tp, common_type_t<_Tp, _Up>> &&
+    ConvertibleTo<_Up, common_type_t<_Tp, _Up>> &&
+    CommonReference<
+        add_lvalue_reference_t<const _Tp>,
+        add_lvalue_reference_t<const _Up>> &&
+    CommonReference<
+        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>
+_LIBCPP_CONCEPT_DECL Integral = is_integral_v<_Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL __integral_has_negatives = _Tp(-1) < _Tp(0);
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL SignedIntegral = Integral<_Tp> && __integral_has_negatives<_Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL UnsignedIntegral = Integral<_Tp> && !__integral_has_negatives<_Tp>;
+
+template <class _Lhs, class _Rhs>
+_LIBCPP_CONCEPT_DECL Assignable =
+    is_lvalue_reference_v<_Lhs> &&
+    CommonReference<
+        const remove_reference_t<_Lhs>&,
+        const remove_reference_t<_Rhs>&> &&
+    requires(_Lhs __left, _Rhs&& __right) {
+        __left = static_cast<_Rhs&&>(__right);
+        requires Same<_Lhs, decltype(__left = static_cast<_Rhs&&>(__right))>;
+    };
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL Swappable = is_swappable_v<_Tp>;
+
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL SwappableWith =
+    is_swappable_with_v<_Tp, _Tp> && is_swappable_with_v<_Up, _Up> &&
+    CommonReference<const remove_reference_t<_Tp>&, const remove_reference_t<_Up>&> &&
+    is_swappable_with_v<_Tp, _Up> && is_swappable_with_v<_Up, _Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL Destructible = is_nothrow_destructible_v<_Tp>;
+
+template <class _Tp, class... _Args>
+_LIBCPP_CONCEPT_DECL Constructible =
+    Destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL DefaultConstructible = Constructible<_Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL MoveConstructible =
+    Constructible<_Tp, _Tp> && ConvertibleTo<_Tp, _Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL CopyConstructible =
+    MoveConstructible<_Tp> &&
+    Constructible<_Tp, _Tp&> && ConvertibleTo<_Tp&, _Tp> &&
+    Constructible<_Tp, const _Tp&> && ConvertibleTo<const _Tp&, _Tp> &&
+    Constructible<_Tp, const _Tp> && ConvertibleTo<const _Tp, _Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL Movable =
+    is_object_v<_Tp> &&
+    MoveConstructible<_Tp> &&
+    Assignable<_Tp&, _Tp> &&
+    Swappable<_Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL Boolean =
+    Movable<remove_cvref_t<_Tp>> &&
+    requires(const remove_reference_t<_Tp>& __t1,
+             const remove_reference_t<_Tp>& __t2, const bool __b) {
+        requires ConvertibleTo<const remove_reference_t<_Tp>&, bool>;
+        !__t1;        requires ConvertibleTo<decltype(!__t1), bool>;
+        __t1 && __t2; requires Same<decltype(__t1 && __t2), bool>;
+        __t1 &&  __b; requires Same<decltype(__t1 &&  __b), bool>;
+         __b && __t2; requires Same<decltype( __b && __t2), bool>;
+        __t1 || __t2; requires Same<decltype(__t1 || __t2), bool>;
+        __t1 ||  __b; requires Same<decltype(__t1 ||  __b), bool>;
+         __b || __t2; requires Same<decltype( __b || __t2), bool>;
+        __t1 == __t2; requires ConvertibleTo<decltype(__t1 == __t2), bool>;
+        __t1 ==  __b; requires ConvertibleTo<decltype(__t1 ==  __b), bool>;
+         __b == __t2; requires ConvertibleTo<decltype( __b == __t2), bool>;
+        __t1 != __t2; requires ConvertibleTo<decltype(__t1 != __t2), bool>;
+        __t1 !=  __b; requires ConvertibleTo<decltype(__t1 !=  __b), bool>;
+         __b != __t2; requires ConvertibleTo<decltype( __b != __t2), bool>;
+    };
+
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL __weakly_equality_comparable =
+    requires(const remove_reference_t<_Tp>& __t,
+             const remove_reference_t<_Up>& __u) {
+        __t == __u; requires Boolean<decltype(__t == __u)>;
+        __t != __u; requires Boolean<decltype(__t != __u)>;
+        __u == __t; requires Boolean<decltype(__u == __t)>;
+        __u != __t; requires Boolean<decltype(__u != __t)>;
+    };
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL EqualityComparable = __weakly_equality_comparable<_Tp, _Tp>;
+
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL EqualityComparableWith =
+    EqualityComparable<_Tp> &&
+    EqualityComparable<_Up> &&
+    CommonReference<
+        const remove_reference_t<_Tp>&,
+        const remove_reference_t<_Up>&> &&
+    EqualityComparable<
+        common_reference_t<
+            const remove_reference_t<_Tp>&,
+            const remove_reference_t<_Up>&>> &&
+    __weakly_equality_comparable<_Tp, _Up>;
+
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL __totally_ordered =
+    requires(const remove_reference_t<_Tp>& __t,
+             const remove_reference_t<_Up>& __u) {
+        __t <  __u; requires Boolean<decltype(__t <  __u)>;
+        __t >  __u; requires Boolean<decltype(__t >  __u)>;
+        __t <= __u; requires Boolean<decltype(__t <= __u)>;
+        __t >= __u; requires Boolean<decltype(__t >= __u)>;
+    };
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL StrictTotallyOrdered =
+    EqualityComparable<_Tp> && __totally_ordered<_Tp, _Tp>;
+
+template <class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL StrictTotallyOrderedWith =
+    StrictTotallyOrdered<_Tp> &&
+    StrictTotallyOrdered<_Up> &&
+    CommonReference<
+        const remove_reference_t<_Tp>&,
+        const remove_reference_t<_Up>&> &&
+    StrictTotallyOrdered<
+        common_reference_t<
+            const remove_reference_t<_Tp>&,
+            const remove_reference_t<_Up>&>> &&
+    EqualityComparableWith<_Tp, _Up> &&
+    __totally_ordered<_Tp, _Up> &&
+    __totally_ordered<_Up, _Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL Copyable =
+    CopyConstructible<_Tp> &&
+    Movable<_Tp> &&
+    Assignable<_Tp&, const _Tp&>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL Semiregular = Copyable<_Tp> && DefaultConstructible<_Tp>;
+
+template <class _Tp>
+_LIBCPP_CONCEPT_DECL Regular = Semiregular<_Tp> && EqualityComparable<_Tp>;
+
+template <class _Fn, class... _Args>
+_LIBCPP_CONCEPT_DECL Invocable = requires(_Fn&& __fn, _Args&&... __args) {
+    _VSTD::__invoke_constexpr(static_cast<_Fn&&>(__fn), static_cast<_Args&&>(__args)...);
+};
+
+template <class _Fn, class... _Args>
+_LIBCPP_CONCEPT_DECL RegularInvocable = Invocable<_Fn, _Args...>;
+
+template <class _Fn, class... _Args>
+_LIBCPP_CONCEPT_DECL Predicate = RegularInvocable<_Fn, _Args...> &&
+    Boolean<invoke_result_t<_Fn, _Args...>>;
+
+template <class _Fn, class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL Relation =
+    Predicate<_Fn, _Tp, _Tp> &&
+    Predicate<_Fn, _Up, _Up> &&
+    CommonReference<
+        const remove_reference_t<_Tp>&,
+        const remove_reference_t<_Up>&> &&
+    Predicate<_Fn,
+        common_reference_t<
+            const remove_reference_t<_Tp>&,
+            const remove_reference_t<_Up>&>,
+        common_reference_t<
+            const remove_reference_t<_Tp>&,
+            const remove_reference_t<_Up>&>> &&
+    Predicate<_Fn, _Tp, _Up> &&
+    Predicate<_Fn, _Up, _Tp>;
+
+template <class _Fn, class _Tp, class _Up>
+_LIBCPP_CONCEPT_DECL StrictWeakOrder = Relation<_Fn, _Tp, _Up>;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#undef _LIBCPP_CONCEPT_DECL
+
+#endif  // !defined(_LIBCPP_HAS_NO_CONCEPTS) && _LIBCPP_STD_VER > 17
+
+_LIBCPP_POP_MACROS
+
+#endif  // _LIBCPP_CONCEPTS

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 *

test/libcxx/concepts/lit.local.cfg

+# If the compiler doesn't support concepts, mark all of the tests under
+# this directory as unsupported.
+if 'concepts' not in config.available_features:
+  config.unsupported = True
+elif 'fconcepts' in config.available_features:
+  # The compiler supports concepts only with the flag - require it.
+  import copy
+  config.test_format.cxx = copy.deepcopy(config.test_format.cxx)
+  config.test_format.cxx.compile_flags += ['-fconcepts']

test/libcxx/concepts/version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <concepts>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main() {}

test/libcxx/double_include.sh.cpp

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

test/libcxx/min_max_macros.sh.cpp

 #include <cmath>
 TEST_MACROS();
 #include <codecvt>
 TEST_MACROS();
 #include <complex>
 TEST_MACROS();
 #include <complex.h>
 TEST_MACROS();
+#include <concepts>
+TEST_MACROS();
 #include <condition_variable>
 TEST_MACROS();
 #include <csetjmp>
 TEST_MACROS();
 #include <csignal>
 TEST_MACROS();
 #include <cstdarg>
 TEST_MACROS();

utils/libcxx/test/config.py

def configure(self):
         self.configure_env()
         self.configure_color_diagnostics()
         self.configure_debug_mode()
         self.configure_warnings()
         self.configure_sanitizer()
         self.configure_coverage()
         self.configure_modules()
         self.configure_coroutines()
+        self.configure_concepts()
         self.configure_substitutions()
         self.configure_features()
 
     def print_config_info(self):
         # Print the final compile and link flags.
         self.lit_config.note('Using compiler: %s' % self.cxx.path)
         self.lit_config.note('Using flags: %s' % self.cxx.flags)
         if self.cxx.use_modules:
def configure_coroutines(self):
             if '__cpp_coroutines' not in macros:
                 self.lit_config.warning('-fcoroutines-ts is supported but '
                     '__cpp_coroutines is not defined')
             # Consider coroutines supported only when the feature test macro
             # reflects a recent value.
             if intMacroValue(macros['__cpp_coroutines']) >= 201703:
                 self.config.available_features.add('fcoroutines-ts')
 
+    def configure_concepts(self):
+        # If the compiler supports concepts, add the 'concepts' feature.
+        # If it requires the '-fconcepts' flag to do so, additionally add the
+        # 'fconcepts' feature.
+        macros = self._dump_macros_verbose()
+        if '__cpp_concepts' in macros and intMacroValue(macros['__cpp_concepts']) >= 201507:
+            self.config.available_features.add('concepts')
+        elif self.cxx.hasCompileFlag('-fconcepts'):
+            macros = self._dump_macros_verbose(flags=['-fconcepts'])
+            if '__cpp_concepts' not in macros:
+                self.lit_config.warning('-fconcepts is supported but '
+                    '__cpp_concepts is not defined')
+            if intMacroValue(macros['__cpp_concepts']) >= 201507:
+                self.config.available_features.add('concepts')
+                self.config.available_features.add('fconcepts')
+
     def configure_modules(self):
         modules_flags = ['-fmodules']
         if platform.system() != 'Darwin':
             modules_flags += ['-Xclang', '-fmodules-local-submodule-visibility']
         supports_modules = self.cxx.hasCompileFlag(modules_flags)
         enable_modules = self.get_modules_enabled()
         if enable_modules and not supports_modules:
             self.lit_config.fatal(