This is an archive of the discontinued LLVM Phabricator instance.

Differential D113170

[DO NOT COMMIT] Test if the libcxx CI system uses the updated clang compiler
AbandonedPublic

Authored by ChuanqiXu on Nov 3 2021, 11:50 PM.

Details

Reviewers
None
Summary

The content of this diff is the same as D109433. The CI's result of D109433 would fail all the way. It runs well locally. And from the error message from the CI, the reason looks like it didn't use the updated compiler. The intention of this diff is to test this.

Diff Detail

Unit TestsFailed

TimeTest
200 mslibcxx CI C++03 > llvm-libc++-shared-cfg-in.std/language_support/support_limits/support_limits_general::coroutine.version.pass.cpp
200 mslibcxx CI C++11 > llvm-libc++-shared-cfg-in.std/language_support/support_limits/support_limits_general::coroutine.version.pass.cpp
240 mslibcxx CI C++14 > llvm-libc++-shared-cfg-in.std/language_support/support_limits/support_limits_general::coroutine.version.pass.cpp
230 mslibcxx CI C++17 > llvm-libc++-shared-cfg-in.std/language_support/support_limits/support_limits_general::coroutine.version.pass.cpp
220 mslibcxx CI C++20 > llvm-libc++-shared-cfg-in.libcxx/inclusions::coroutine.inclusions.compile.pass.cpp
View Full Test Results (8 Failed)

Event Timeline

ChuanqiXu created this revision.Nov 3 2021, 11:50 PM
Herald added subscribers: lxfind, arichardson, mgorny. · View Herald TranscriptNov 3 2021, 11:50 PM
ChuanqiXu requested review of this revision.Nov 3 2021, 11:50 PM
ChuanqiXu removed subscribers: mgorny, arichardson, lxfind.
Harbormaster completed remote builds in B132394: Diff 384671.Nov 4 2021, 12:13 AM
ChuanqiXu added a project: Restricted Project.Nov 4 2021, 12:21 AM
ChuanqiXu abandoned this revision.Nov 4 2021, 12:42 AM
ChuanqiXu updated this revision to Diff 384971.Nov 4 2021, 10:29 PM

Emit an error if it find the compiler didn't implement __cpp_impl_coroutine macro. It should be implemented in ec11715.

Harbormaster completed remote builds in B132615: Diff 384971.Nov 4 2021, 11:33 PM
ChuanqiXu added inline comments.Nov 4 2021, 11:44 PM
libcxx/include/coroutine
44–46

I added a check here to see if the compiler introduced macro __cpp_impl_coroutine, which should be introduced at https://github.com/llvm/llvm-project/commit/ec117158a390a0ebf64377caa5abd0c976df8f7a.

ChuanqiXu mentioned this in D109433: [libcxx] [coroutine] Conform coroutine implementation.Nov 4 2021, 11:48 PM
ChuanqiXu abandoned this revision.Nov 5 2021, 10:23 PM
ChuanqiXu updated this revision to Diff 385395.Nov 7 2021, 9:14 PM

Update again

Harbormaster completed remote builds in B132947: Diff 385395.Nov 7 2021, 9:16 PM
ChuanqiXu updated this revision to Diff 385397.Nov 7 2021, 9:17 PM

Test again

Harbormaster completed remote builds in B132949: Diff 385397.Nov 7 2021, 9:37 PM
ChuanqiXu abandoned this revision.Nov 8 2021, 6:02 PM

Revision Contents

PathSize
libcxx/
docs/
2 lines
Status/
2 lines
2 lines
include/
5 lines
4 lines
__coroutine/
228 lines
53 lines
46 lines
86 lines
56 lines
experimental/
4 lines
6 lines
13 lines
2 lines
test/
libcxx/
diagnostics/
detail.headers/
coroutine/
15 lines
15 lines
15 lines
15 lines
5 lines
inclusions/
28 lines
6 lines
5 lines
std/
experimental/
language.support/
support.coroutines/
end.to.end/
71 lines
language.support/
support.coroutines/
coroutine.handle/
coroutine.handle.hash/
62 lines
coroutine.handle.capacity/
56 lines
coroutine.handle.compare/
59 lines
66 lines
coroutine.handle.completion/
43 lines
coroutine.handle.con/
54 lines
49 lines
coroutine.handle.export/
53 lines
58 lines
coroutine.handle.noop/
76 lines
coroutine.handle.prom/
83 lines
coroutine.handle.resumption/
60 lines
78 lines
50 lines
coroutine.traits/
76 lines
coroutine.trivial.awaitables/
75 lines
84 lines
end.to.end/
70 lines
70 lines
88 lines
110 lines
161 lines
176 lines
88 lines
73 lines
support.limits/
support.limits.general/
63 lines
32 lines
support/
utils/
1 line
2 lines
3 lines
libcxx/
test/
1 line

Diff 385397

libcxx/docs/FeatureTestMacroTable.rst

Show First 20 Lines • Show All 218 Lines • ▼ Show 20 Lines.. table:: Current Status
``__cpp_lib_constexpr_string_view`` ``201811L`` ``__cpp_lib_constexpr_string_view`` ``201811L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_constexpr_tuple`` ``201811L`` ``__cpp_lib_constexpr_tuple`` ``201811L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_constexpr_utility`` ``201811L`` ``__cpp_lib_constexpr_utility`` ``201811L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_constexpr_vector`` *unimplemented* ``__cpp_lib_constexpr_vector`` *unimplemented*
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_coroutine`` *unimplemented* ``__cpp_lib_coroutine`` ``201902L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_destroying_delete`` ``201806L`` ``__cpp_lib_destroying_delete`` ``201806L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_endian`` ``201907L`` ``__cpp_lib_endian`` ``201907L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_erase_if`` ``202002L`` ``__cpp_lib_erase_if`` ``202002L``
------------------------------------------------- ----------------- ------------------------------------------------- -----------------
``__cpp_lib_execution`` *unimplemented* ``__cpp_lib_execution`` *unimplemented*
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

libcxx/docs/Status/Cxx20Issues.csv

Show First 20 Lines • Show All 286 Lines • ▼ Show 20 Lines
"`3382 <https://wg21.link/LWG3382>`__","NTTP for ``pair``\ and ``array``\ ","Prague","","" "`3382 <https://wg21.link/LWG3382>`__","NTTP for ``pair``\ and ``array``\ ","Prague","",""
"`3383 <https://wg21.link/LWG3383>`__","|sect|\ [time.zone.leap.nonmembers] ``sys_seconds``\ should be replaced with ``seconds``\ ","Prague","","","|chrono|" "`3383 <https://wg21.link/LWG3383>`__","|sect|\ [time.zone.leap.nonmembers] ``sys_seconds``\ should be replaced with ``seconds``\ ","Prague","","","|chrono|"
"`3384 <https://wg21.link/LWG3384>`__","``transform_view::*sentinel*``\ has an incorrect ``operator-``\ ","Prague","","","|ranges|" "`3384 <https://wg21.link/LWG3384>`__","``transform_view::*sentinel*``\ has an incorrect ``operator-``\ ","Prague","","","|ranges|"
"`3385 <https://wg21.link/LWG3385>`__","``common_iterator``\ is not sufficiently constrained for non-copyable iterators","Prague","","","|ranges|" "`3385 <https://wg21.link/LWG3385>`__","``common_iterator``\ is not sufficiently constrained for non-copyable iterators","Prague","","","|ranges|"
"`3387 <https://wg21.link/LWG3387>`__","|sect|\ [range.reverse.view] ``reverse_view<V>``\ unintentionally requires ``range<const V>``\ ","Prague","","","|ranges|" "`3387 <https://wg21.link/LWG3387>`__","|sect|\ [range.reverse.view] ``reverse_view<V>``\ unintentionally requires ``range<const V>``\ ","Prague","","","|ranges|"
"`3388 <https://wg21.link/LWG3388>`__","``view``\ iterator types have ill-formed ``<=>``\ operators","Prague","","","|ranges|" "`3388 <https://wg21.link/LWG3388>`__","``view``\ iterator types have ill-formed ``<=>``\ operators","Prague","","","|ranges|"
"`3389 <https://wg21.link/LWG3389>`__","A move-only iterator still does not have a ``counted_iterator``\ ","Prague","","","|ranges|" "`3389 <https://wg21.link/LWG3389>`__","A move-only iterator still does not have a ``counted_iterator``\ ","Prague","","","|ranges|"
"`3390 <https://wg21.link/LWG3390>`__","``make_move_iterator()``\ cannot be used to construct a ``move_iterator``\ for a move-only iterator","Prague","","","|ranges|" "`3390 <https://wg21.link/LWG3390>`__","``make_move_iterator()``\ cannot be used to construct a ``move_iterator``\ for a move-only iterator","Prague","","","|ranges|"
"`3393 <https://wg21.link/LWG3393>`__","Missing/incorrect feature test macro for coroutines","Prague","","" "`3393 <https://wg21.link/LWG3393>`__","Missing/incorrect feature test macro for coroutines","Prague","|Complete|","14.0"
"`3395 <https://wg21.link/LWG3395>`__","Definition for three-way comparison needs to be updated (US 152)","Prague","","","|spaceship|" "`3395 <https://wg21.link/LWG3395>`__","Definition for three-way comparison needs to be updated (US 152)","Prague","","","|spaceship|"
"`3396 <https://wg21.link/LWG3396>`__","Clarify point of reference for ``source_location::current()``\ (DE 169)","Prague","","" "`3396 <https://wg21.link/LWG3396>`__","Clarify point of reference for ``source_location::current()``\ (DE 169)","Prague","",""
"`3397 <https://wg21.link/LWG3397>`__","``ranges::basic_istream_view::iterator``\ should not provide ``iterator_category``\ ","Prague","","","|ranges|" "`3397 <https://wg21.link/LWG3397>`__","``ranges::basic_istream_view::iterator``\ should not provide ``iterator_category``\ ","Prague","","","|ranges|"
"`3398 <https://wg21.link/LWG3398>`__","``tuple_element_t``\ is also wrong for ``const subrange``\ ","Prague","|Complete|","14.0","|ranges|" "`3398 <https://wg21.link/LWG3398>`__","``tuple_element_t``\ is also wrong for ``const subrange``\ ","Prague","|Complete|","14.0","|ranges|"
"`3446 <https://wg21.link/LWG3446>`__","``indirectly_readable_traits``\ ambiguity for types with both ``value_type``\ and ``element_type``\ ","November virtual meeting","|Complete|","13.0" "`3446 <https://wg21.link/LWG3446>`__","``indirectly_readable_traits``\ ambiguity for types with both ``value_type``\ and ``element_type``\ ","November virtual meeting","|Complete|","13.0"

libcxx/docs/Status/SpaceshipProjects.csv

Section,Description,Dependencies,Assignee,Complete Section,Description,Dependencies,Assignee,Complete
| `[cmp.concept] <https://wg21.link/cmp.concept>`_,"| `three_way_comparable <https://reviews.llvm.org/D103478>`_ | `[cmp.concept] <https://wg21.link/cmp.concept>`_,"| `three_way_comparable <https://reviews.llvm.org/D103478>`_
| `three_way_comparable_with <https://reviews.llvm.org/D103478>`_",None,Ruslan Arutyunyan,|In Progress| | `three_way_comparable_with <https://reviews.llvm.org/D103478>`_",None,Ruslan Arutyunyan,|In Progress|
| `[cmp.result] <https://wg21.link/cmp.result>`_,| `compare_three_way_result <https://reviews.llvm.org/D103581>`_,None,Arthur O'Dwyer,|Complete| | `[cmp.result] <https://wg21.link/cmp.result>`_,| `compare_three_way_result <https://reviews.llvm.org/D103581>`_,None,Arthur O'Dwyer,|Complete|
| `[expos.only.func] <https://wg21.link/expos.only.func>`_,"| `synth-three-way <https://reviews.llvm.org/D107721>`_ | `[expos.only.func] <https://wg21.link/expos.only.func>`_,"| `synth-three-way <https://reviews.llvm.org/D107721>`_
| `synth-three-way-result <https://reviews.llvm.org/D107721>`_",[cmp.concept],Kent Ross,|Complete| | `synth-three-way-result <https://reviews.llvm.org/D107721>`_",[cmp.concept],Kent Ross,|Complete|
| `[comparisons.three.way] <https://wg21.link/comparisons.three.way>`_,| `compare_three_way <https://reviews.llvm.org/D80899>`_,[cmp.concept],Arthur O'Dwyer,|Complete| | `[comparisons.three.way] <https://wg21.link/comparisons.three.way>`_,| `compare_three_way <https://reviews.llvm.org/D80899>`_,[cmp.concept],Arthur O'Dwyer,|Complete|
| `[cmp.alg] <https://wg21.link/cmp.alg>`_,"| `strong_order <https://reviews.llvm.org/D107036>`_ | `[cmp.alg] <https://wg21.link/cmp.alg>`_,"| `strong_order <https://reviews.llvm.org/D107036>`_
| `weak_order <https://reviews.llvm.org/D107036>`_ | `weak_order <https://reviews.llvm.org/D107036>`_
| `partial_order <https://reviews.llvm.org/D107036>`_",None,Arthur O'Dwyer,|In Progress| | `partial_order <https://reviews.llvm.org/D107036>`_",None,Arthur O'Dwyer,|In Progress|
| `[alg.three.way] <https://wg21.link/alg.three.way>`_,| `lexicographical_compare_three_way <https://reviews.llvm.org/D80902>`_,[comparisons.three.way],Christopher Di Bella,|In Progress| | `[alg.three.way] <https://wg21.link/alg.three.way>`_,| `lexicographical_compare_three_way <https://reviews.llvm.org/D80902>`_,[comparisons.three.way],Christopher Di Bella,|In Progress|
| `[coroutine.handle.compare] <https://wg21.link/coroutine.handle.compare>`_,| coroutine_handle,[comparisons.three.way],Unassigned,|Not Started| | `[coroutine.handle.compare] <https://wg21.link/coroutine.handle.compare>`_,| coroutine_handle,[comparisons.three.way],Unassigned,|Complete|
| `[pairs.spec] <https://wg21.link/pairs.spec>`_,| `pair <https://reviews.llvm.org/D107721>`_,[expos.only.func],Kent Ross,|Complete| | `[pairs.spec] <https://wg21.link/pairs.spec>`_,| `pair <https://reviews.llvm.org/D107721>`_,[expos.only.func],Kent Ross,|Complete|
| `[syserr.errcat.nonvirtuals] <https://wg21.link/syserr.errcat.nonvirtuals>`_,| error_category,[comparisons.three.way],Unassigned,|Not Started| | `[syserr.errcat.nonvirtuals] <https://wg21.link/syserr.errcat.nonvirtuals>`_,| error_category,[comparisons.three.way],Unassigned,|Not Started|
| `[syserr.compare] <https://wg21.link/syserr.compare>`_,"| error_code | `[syserr.compare] <https://wg21.link/syserr.compare>`_,"| error_code
| error_condition",None,Unassigned,|Not Started| | error_condition",None,Unassigned,|Not Started|
| `[tuple.rel] <https://wg21.link/tuple.rel>`_,| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,|Complete| | `[tuple.rel] <https://wg21.link/tuple.rel>`_,| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,|Complete|
"| `[optional.relops] <https://wg21.link/optional.relops>`_ "| `[optional.relops] <https://wg21.link/optional.relops>`_
| `[optional.nullops] <https://wg21.link/optional.nullops>`_ | `[optional.nullops] <https://wg21.link/optional.nullops>`_
| `[optional.comp.with.t] <https://wg21.link/optional.comp.with.t>`_","| optional | `[optional.comp.with.t] <https://wg21.link/optional.comp.with.t>`_","| optional
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/include/CMakeLists.txt

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Linesset(files
__concepts/predicate.h __concepts/predicate.h
__concepts/regular.h __concepts/regular.h
__concepts/relation.h __concepts/relation.h
__concepts/same_as.h __concepts/same_as.h
__concepts/semiregular.h __concepts/semiregular.h
__concepts/swappable.h __concepts/swappable.h
__concepts/totally_ordered.h __concepts/totally_ordered.h
__config __config
__coroutine/coroutine_handle.h
__coroutine/noop_coroutine_handle.h
__coroutine/coroutine_traits.h
__coroutine/coroutine_trivial_awaitables.h
__debug __debug
__errc __errc
__format/format_arg.h __format/format_arg.h
__format/format_args.h __format/format_args.h
__format/format_context.h __format/format_context.h
__format/format_error.h __format/format_error.h
__format/format_fwd.h __format/format_fwd.h
__format/format_parse_context.h __format/format_parse_context.h
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Linesset(files
clocale clocale
cmath cmath
codecvt codecvt
compare compare
complex complex
complex.h complex.h
concepts concepts
condition_variable condition_variable
coroutine
csetjmp csetjmp
csignal csignal
cstdarg cstdarg
cstdbool cstdbool
cstddef cstddef
cstdint cstdint
cstdio cstdio
cstdlib cstdlib
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/include/__config

Show First 20 Lines • Show All 1,267 Lines • ▼ Show 20 Lines
#if defined(_LIBCPP_ENABLE_CXX20_REMOVED_FEATURES) #if defined(_LIBCPP_ENABLE_CXX20_REMOVED_FEATURES)
#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
#define _LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS #define _LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS
#define _LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS #define _LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
#define _LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR #define _LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR
#define _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS #define _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS
#endif // _LIBCPP_ENABLE_CXX20_REMOVED_FEATURES #endif // _LIBCPP_ENABLE_CXX20_REMOVED_FEATURES
#if !defined(__cpp_coroutines) || __cpp_coroutines < 201703L #if !defined(__cpp_impl_coroutine) || __cpp_impl_coroutine < 201902L
#define _LIBCPP_HAS_NO_COROUTINES #define _LIBCPP_HAS_NO_CXX20_COROUTINES
#endif #endif
#if !defined(__cpp_impl_three_way_comparison) || __cpp_impl_three_way_comparison < 201907L #if !defined(__cpp_impl_three_way_comparison) || __cpp_impl_three_way_comparison < 201907L
#define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR #define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
#endif #endif
#if defined(_LIBCPP_COMPILER_IBM) #if defined(_LIBCPP_COMPILER_IBM)
#define _LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO #define _LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

libcxx/include/__coroutine/coroutine_handle.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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___COROUTINE_COROUTINE_HANDLE_H
#define _LIBCPP___COROUTINE_COROUTINE_HANDLE_H
#include <__config>
#include <__debug>
#include <__functional/hash.h>
#include <__memory/addressof.h>
#include <compare>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
_LIBCPP_BEGIN_NAMESPACE_STD
// [coroutine.handle]
template <class _Promise = void>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle;
template <>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle<void> {
public:
// [coroutine.handle.con], construct/reset
_LIBCPP_HIDE_FROM_ABI
constexpr coroutine_handle() noexcept = default;
_LIBCPP_HIDE_FROM_ABI
constexpr coroutine_handle(nullptr_t) noexcept {}
_LIBCPP_HIDE_FROM_ABI
coroutine_handle& operator=(nullptr_t) noexcept {
__handle_ = nullptr;
return *this;
}
// [coroutine.handle.export.import], export/import
_LIBCPP_HIDE_FROM_ABI
constexpr void* address() const noexcept { return __handle_; }
_LIBCPP_HIDE_FROM_ABI
static constexpr coroutine_handle from_address(void* __addr) noexcept {
coroutine_handle __tmp;
__tmp.__handle_ = __addr;
return __tmp;
}
// [coroutine.handle.observers], observers
_LIBCPP_HIDE_FROM_ABI
constexpr explicit operator bool() const noexcept {
return __handle_ != nullptr;
}
_LIBCPP_HIDE_FROM_ABI
bool done() const {
_LIBCPP_ASSERT(__is_suspended(), "done() can be called only on suspended coroutines");
return __builtin_coro_done(__handle_);
}
// [coroutine.handle.resumption], resumption
_LIBCPP_HIDE_FROM_ABI
void operator()() const { resume(); }
_LIBCPP_HIDE_FROM_ABI
void resume() const {
_LIBCPP_ASSERT(__is_suspended(), "resume() can be called only on suspended coroutines");
_LIBCPP_ASSERT(!done(), "resume() has undefined behavior when the coroutine is done");
__builtin_coro_resume(__handle_);
}
_LIBCPP_HIDE_FROM_ABI
void destroy() const {
_LIBCPP_ASSERT(__is_suspended(), "destroy() can be called only on suspended coroutines");
__builtin_coro_destroy(__handle_);
}
private:
bool __is_suspended() const {
// FIXME actually implement a check for if the coro is suspended.
return __handle_ != nullptr;
}
void* __handle_ = nullptr;
};
// [coroutine.handle.compare]
#if defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
inline _LIBCPP_HIDE_FROM_ABI
constexpr bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return __x.address() == __y.address();
}
inline _LIBCPP_HIDE_FROM_ABI
constexpr bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return less<void*>()(__x.address(), __y.address());
}
inline _LIBCPP_HIDE_FROM_ABI
constexpr bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return __y < __x;
}
inline _LIBCPP_HIDE_FROM_ABI
constexpr bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return !(__x > __y);
}
inline _LIBCPP_HIDE_FROM_ABI
constexpr bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return !(__x < __y);
}
#else
inline _LIBCPP_HIDE_FROM_ABI
constexpr bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return __x.address() == __y.address();
}
inline _LIBCPP_HIDE_FROM_ABI
constexpr strong_ordering operator<=>(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
return compare_three_way()(__x.address(), __y.address());
}
#endif // defined(_LIBCPP_HAS_NO_SPACESHIP_OPERATOR)
template <class _Promise>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle {
public:
// [coroutine.handle.con], construct/reset
_LIBCPP_HIDE_FROM_ABI
constexpr coroutine_handle() noexcept = default;
_LIBCPP_HIDE_FROM_ABI
constexpr coroutine_handle(nullptr_t) noexcept {}
_LIBCPP_HIDE_FROM_ABI
static coroutine_handle from_promise(_Promise& __promise) {
using _RawPromise = typename remove_cv<_Promise>::type;
coroutine_handle __tmp;
__tmp.__handle_ =
__builtin_coro_promise(_VSTD::addressof(const_cast<_RawPromise&>(__promise)), alignof(_Promise), true);
return __tmp;
}
_LIBCPP_HIDE_FROM_ABI
coroutine_handle& operator=(nullptr_t) noexcept {
__handle_ = nullptr;
return *this;
}
// [coroutine.handle.export.import], export/import
_LIBCPP_HIDE_FROM_ABI
constexpr void* address() const noexcept { return __handle_; }
_LIBCPP_HIDE_FROM_ABI
static constexpr coroutine_handle from_address(void* __addr) noexcept {
coroutine_handle __tmp;
__tmp.__handle_ = __addr;
return __tmp;
}
// [coroutine.handle.conv], conversion
_LIBCPP_HIDE_FROM_ABI
constexpr operator coroutine_handle<>() const noexcept {
return coroutine_handle<>::from_address(address());
}
// [coroutine.handle.observers], observers
_LIBCPP_HIDE_FROM_ABI
constexpr explicit operator bool() const noexcept {
return __handle_ != nullptr;
}
_LIBCPP_HIDE_FROM_ABI
bool done() const {
_LIBCPP_ASSERT(__is_suspended(), "done() can be called only on suspended coroutines");
return __builtin_coro_done(__handle_);
}
// [coroutine.handle.resumption], resumption
_LIBCPP_HIDE_FROM_ABI
void operator()() const { resume(); }
_LIBCPP_HIDE_FROM_ABI
void resume() const {
_LIBCPP_ASSERT(__is_suspended(), "resume() can be called only on suspended coroutines");
_LIBCPP_ASSERT(!done(), "resume() has undefined behavior when the coroutine is done");
__builtin_coro_resume(__handle_);
}
_LIBCPP_HIDE_FROM_ABI
void destroy() const {
_LIBCPP_ASSERT(__is_suspended(), "destroy() can be called only on suspended coroutines");
__builtin_coro_destroy(__handle_);
}
// [coroutine.handle.promise], promise access
_LIBCPP_HIDE_FROM_ABI
_Promise& promise() const {
return *static_cast<_Promise*>(__builtin_coro_promise(this->__handle_, alignof(_Promise), false));
}
private:
bool __is_suspended() const {
// FIXME actually implement a check for if the coro is suspended.
return __handle_ != nullptr;
}
void* __handle_ = nullptr;
};
// [coroutine.handle.hash]
template <class _Tp>
struct hash<coroutine_handle<_Tp>> {
_LIBCPP_HIDE_FROM_ABI
size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept { return hash<void*>()(__v.address()); }
};
_LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
#endif // _LIBCPP___COROUTINE_COROUTINE_HANDLE_H

libcxx/include/__coroutine/coroutine_traits.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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___COROUTINE_COROUTINE_TRAITS_H
#define _LIBCPP___COROUTINE_COROUTINE_TRAITS_H
#include <__config>
#include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
_LIBCPP_BEGIN_NAMESPACE_STD
// [coroutine.traits]
// [coroutine.traits.primary]
// The header <coroutine> defined the primary template coroutine_traits such that
// if ArgTypes is a parameter pack of types and if the qualified-id R::promise_type
// is valid and denotes a type ([temp.deduct]), then coroutine_traits<R, ArgTypes...>
// has the following publicly accessible memebr:
//
// using promise_type = typename R::promise_type;
//
// Otherwise, coroutine_traits<R, ArgTypes...> has no members.
template <class _Tp, class = void>
struct __coroutine_traits_sfinae {};
template <class _Tp>
struct __coroutine_traits_sfinae<
_Tp, typename __void_t<typename _Tp::promise_type>::type>
{
using promise_type = typename _Tp::promise_type;
};
template <class _Ret, class... _Args>
struct coroutine_traits
: public __coroutine_traits_sfinae<_Ret>
{
};
_LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
#endif // _LIBCPP___COROUTINE_COROUTINE_TRAITS_H

libcxx/include/__coroutine/coroutine_trivial_awaitables.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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___COROUTINE_TRIVIAL_AWAITABLES_H
#define __LIBCPP___COROUTINE_TRIVIAL_AWAITABLES_H
#include <__config>
#include <__coroutine/coroutine_handle.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
_LIBCPP_BEGIN_NAMESPACE_STD
// [coroutine.trivial.awaitables]
struct suspend_never {
_LIBCPP_HIDE_FROM_ABI
constexpr bool await_ready() const noexcept { return true; }
_LIBCPP_HIDE_FROM_ABI
constexpr void await_suspend(coroutine_handle<>) const noexcept {}
_LIBCPP_HIDE_FROM_ABI
constexpr void await_resume() const noexcept {}
};
struct suspend_always {
_LIBCPP_HIDE_FROM_ABI
constexpr bool await_ready() const noexcept { return false; }
_LIBCPP_HIDE_FROM_ABI
constexpr void await_suspend(coroutine_handle<>) const noexcept {}
_LIBCPP_HIDE_FROM_ABI
constexpr void await_resume() const noexcept {}
};
_LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
#endif // __LIBCPP___COROUTINE_TRIVIAL_AWAITABLES_H

libcxx/include/__coroutine/noop_coroutine_handle.h

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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___COROUTINE_NOOP_COROUTINE_HANDLE_H
#define _LIBCPP___COROUTINE_NOOP_COROUTINE_HANDLE_H
#include <__config>
#include <__coroutine/coroutine_handle.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
_LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__builtin_coro_noop)
// [coroutine.noop]
// [coroutine.promise.noop]
struct noop_coroutine_promise {};
// [coroutine.handle.noop]
template <>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise> {
public:
// [coroutine.handle.noop.conv], conversion
_LIBCPP_HIDE_FROM_ABI
constexpr operator coroutine_handle<>() const noexcept {
return coroutine_handle<>::from_address(address());
}
// [coroutine.handle.noop.observers], observers
_LIBCPP_HIDE_FROM_ABI
constexpr explicit operator bool() const noexcept { return true; }
_LIBCPP_HIDE_FROM_ABI
constexpr bool done() const noexcept { return false; }
// [coroutine.handle.noop.resumption], resumption
_LIBCPP_HIDE_FROM_ABI
constexpr void operator()() const noexcept {}
_LIBCPP_HIDE_FROM_ABI
constexpr void resume() const noexcept {}
_LIBCPP_HIDE_FROM_ABI
constexpr void destroy() const noexcept {}
// [coroutine.handle.noop.promise], promise access
_LIBCPP_HIDE_FROM_ABI
noop_coroutine_promise& promise() const noexcept {
return *static_cast<noop_coroutine_promise*>(
__builtin_coro_promise(this->__handle_, alignof(noop_coroutine_promise), false));
}
// [coroutine.handle.noop.address], address
_LIBCPP_HIDE_FROM_ABI
constexpr void* address() const noexcept { return __handle_; }
private:
_LIBCPP_HIDE_FROM_ABI
friend coroutine_handle<noop_coroutine_promise> noop_coroutine() noexcept;
_LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept {
this->__handle_ = __builtin_coro_noop();
}
void* __handle_ = nullptr;
};
using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
// [coroutine.noop.coroutine]
inline _LIBCPP_HIDE_FROM_ABI
noop_coroutine_handle noop_coroutine() noexcept { return noop_coroutine_handle(); }
#endif // __has_builtin(__builtin_coro_noop)
_LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
#endif // _LIBCPP___COROUTINE_NOOP_COROUTINE_HANDLE_H

libcxx/include/coroutine

  • This file was added.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// 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_COROUTINE
#define _LIBCPP_COROUTINE
/**
coroutine synopsis
namespace std {
// [coroutine.traits]
template <class R, class... ArgTypes>
struct coroutine_traits;
// [coroutine.handle]
template <class Promise = void>
struct coroutine_handle;
// [coroutine.handle.compare]
constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
// [coroutine.handle.hash]
template <class T> struct hash;
template <class P> struct hash<coroutine_handle<P>>;
// [coroutine.noop]
struct noop_coroutine_promise;
template<> struct coroutine_handle<noop_coroutine_promise>;
using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
noop_coroutine_handle noop_coroutine() noexcept;
// [coroutine.trivial.awaitables]
struct suspend_never;
struct suspend_always;
} // namespace std
*/
#include <__config>
#include <__coroutine/coroutine_handle.h>
#include <__coroutine/noop_coroutine_handle.h>
#include <__coroutine/coroutine_traits.h>
#include <__coroutine/coroutine_trivial_awaitables.h>
#include <version>
ChuanqiXuAuthorUnsubmitted
Done
ReplyInline Actions

I added a check here to see if the compiler introduced macro __cpp_impl_coroutine, which should be introduced at https://github.com/llvm/llvm-project/commit/ec117158a390a0ebf64377caa5abd0c976df8f7a.

ChuanqiXu: I added a check here to see if the compiler introduced macro `__cpp_impl_coroutine`, which…
#if defined(_LIBCPP_HAS_NO_CXX20_COROUTINES)
#error "The compiler didn't offer cxx20 coroutines"
#endif
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif
#endif // _LIBCPP_COROUTINE

libcxx/include/experimental/__config

Show All 39 Lines
#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \ #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM { \ _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem _LIBCPP_DEPRECATED_EXPERIMENTAL_FILESYSTEM { \
inline namespace v1 { inline namespace v1 {
#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \ #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
} } _LIBCPP_END_NAMESPACE_EXPERIMENTAL } } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
#if !defined(__cpp_coroutines) || __cpp_coroutines < 201703L
#define _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
#endif
#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \ #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 { _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 {
#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES \ #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES \
} _LIBCPP_END_NAMESPACE_EXPERIMENTAL } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
#define _VSTD_CORO _VSTD_EXPERIMENTAL::coroutines_v1 #define _VSTD_CORO _VSTD_EXPERIMENTAL::coroutines_v1
Show All 20 Lines

libcxx/include/experimental/coroutine

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
#include <memory> // for hash<T*> #include <memory> // for hash<T*>
#include <cstddef> #include <cstddef>
#include <__debug> #include <__debug>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
#ifdef _LIBCPP_HAS_NO_COROUTINES #ifdef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
# if defined(_LIBCPP_WARNING) # if defined(_LIBCPP_WARNING)
_LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler") _LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler")
# else # else
# warning <experimental/coroutine> cannot be used with this compiler # warning <experimental/coroutine> cannot be used with this compiler
# endif # endif
#endif #endif
#ifndef _LIBCPP_HAS_NO_COROUTINES #ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES
template <class _Tp, class = void> template <class _Tp, class = void>
struct __coroutine_traits_sfinae {}; struct __coroutine_traits_sfinae {};
template <class _Tp> template <class _Tp>
struct __coroutine_traits_sfinae< struct __coroutine_traits_sfinae<
▲ Show 20 Lines • Show All 247 Lines • ▼ Show 20 Linesstruct hash<_VSTD_CORO::coroutine_handle<_Tp> > {
using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>; using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(__arg_type const& __v) const _NOEXCEPT size_t operator()(__arg_type const& __v) const _NOEXCEPT
{return hash<void*>()(__v.address());} {return hash<void*>()(__v.address());}
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !defined(_LIBCPP_HAS_NO_COROUTINES) #endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */ #endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */

libcxx/include/module.modulemap

Show First 20 Lines • Show All 411 Lines • ▼ Show 20 Lines module __concepts {
module swappable { private header "__concepts/swappable.h" } module swappable { private header "__concepts/swappable.h" }
module totally_ordered { private header "__concepts/totally_ordered.h" } module totally_ordered { private header "__concepts/totally_ordered.h" }
} }
} }
module condition_variable { module condition_variable {
header "condition_variable" header "condition_variable"
export * export *
} }
module coroutine {
requires coroutines
header "coroutine"
export compare
export *
module __coroutine {
module coroutine_handle { private header "__coroutine/coroutine_handle.h" }
module coroutine_noop { private header "__coroutine/noop_coroutine_handle.h" }
module coroutine_traits { private header "__coroutine/coroutine_traits.h" }
module coroutine_trivial_awaitables { private header "__coroutine/coroutine_trivial_awaitables.h" }
}
}
module deque { module deque {
header "deque" header "deque"
export initializer_list export initializer_list
export * export *
} }
module exception { module exception {
header "exception" header "exception"
export * export *
▲ Show 20 Lines • Show All 551 Lines • Show Last 20 Lines

libcxx/include/version

Show First 20 Lines • Show All 299 Lines • ▼ Show 20 Lines
# define __cpp_lib_constexpr_iterator 201811L # define __cpp_lib_constexpr_iterator 201811L
# define __cpp_lib_constexpr_memory 201811L # define __cpp_lib_constexpr_memory 201811L
# define __cpp_lib_constexpr_numeric 201911L # define __cpp_lib_constexpr_numeric 201911L
# define __cpp_lib_constexpr_string 201811L # define __cpp_lib_constexpr_string 201811L
# define __cpp_lib_constexpr_string_view 201811L # define __cpp_lib_constexpr_string_view 201811L
# define __cpp_lib_constexpr_tuple 201811L # define __cpp_lib_constexpr_tuple 201811L
# define __cpp_lib_constexpr_utility 201811L # define __cpp_lib_constexpr_utility 201811L
// # define __cpp_lib_constexpr_vector 201907L // # define __cpp_lib_constexpr_vector 201907L
// # define __cpp_lib_coroutine 201902L # define __cpp_lib_coroutine 201902L
# if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
# define __cpp_lib_destroying_delete 201806L # define __cpp_lib_destroying_delete 201806L
# endif # endif
# define __cpp_lib_endian 201907L # define __cpp_lib_endian 201907L
# define __cpp_lib_erase_if 202002L # define __cpp_lib_erase_if 202002L
# undef __cpp_lib_execution # undef __cpp_lib_execution
// # define __cpp_lib_execution 201902L // # define __cpp_lib_execution 201902L
# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format)
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

libcxx/test/libcxx/diagnostics/detail.headers/coroutine/coroutine_handle.module.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_handle.h'}}
#include <__coroutine/coroutine_handle.h>

libcxx/test/libcxx/diagnostics/detail.headers/coroutine/coroutine_traits.module.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_traits.h'}}
#include <__coroutine/coroutine_traits.h>

libcxx/test/libcxx/diagnostics/detail.headers/coroutine/coroutine_trivial_awaitables.module.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__coroutine/coroutine_trivial_awaitables.h'}}
#include <__coroutine/coroutine_trivial_awaitables.h>

libcxx/test/libcxx/diagnostics/detail.headers/coroutine/noop_coroutine_handle.module.verify.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// REQUIRES: modules-build
// WARNING: This test was generated by 'generate_private_header_tests.py'
// and should not be edited manually.
// expected-error@*:* {{use of private header from outside its module: '__coroutine/noop_coroutine_handle.h'}}
#include <__coroutine/noop_coroutine_handle.h>

libcxx/test/libcxx/double_include.sh.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
#ifndef _LIBCPP_HAS_NO_LOCALIZATION #ifndef _LIBCPP_HAS_NO_LOCALIZATION
# include <codecvt> # include <codecvt>
#endif #endif
#include <compare> #include <compare>
#include <complex> #include <complex>
#include <complex.h> #include <complex.h>
#include <concepts> #include <concepts>
#include <condition_variable> #include <condition_variable>
#ifndef _LIBCPP_HAS_NO_CXX20_COROUTINES
# include <coroutine>
#endif
#include <csetjmp> #include <csetjmp>
#include <csignal> #include <csignal>
#include <cstdarg> #include <cstdarg>
#include <cstdbool> #include <cstdbool>
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines
#endif #endif
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
# include <wctype.h> # include <wctype.h>
#endif #endif
// experimental headers // experimental headers
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
# include <experimental/algorithm> # include <experimental/algorithm>
# if defined(__cpp_coroutines) # ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
# include <experimental/coroutine> # include <experimental/coroutine>
# endif # endif
# include <experimental/deque> # include <experimental/deque>
# ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY # ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
# include <experimental/filesystem> # include <experimental/filesystem>
# endif # endif
# include <experimental/forward_list> # include <experimental/forward_list>
# include <experimental/functional> # include <experimental/functional>
Show All 31 Lines

libcxx/test/libcxx/inclusions/coroutine.inclusions.compile.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// WARNING: This test was generated by generate_header_inclusion_tests.py
// and should not be edited manually.
//
// clang-format off
// UNSUPPORTED: c++03, c++11, c++14, c++17
// <coroutine>
// Test that <coroutine> includes all the other headers it's supposed to.
#include <coroutine>
#include "test_macros.h"
#if !defined(_LIBCPP_COROUTINE)
# error "<coroutine> was expected to define _LIBCPP_COROUTINE"
#endif
#if TEST_STD_VER > 17 && !defined(_LIBCPP_COMPARE)
# error "<coroutine> should include <compare> in C++20 and later"
#endif

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
#include <complex> #include <complex>
TEST_MACROS(); TEST_MACROS();
#include <complex.h> #include <complex.h>
TEST_MACROS(); TEST_MACROS();
#include <concepts> #include <concepts>
TEST_MACROS(); TEST_MACROS();
#include <condition_variable> #include <condition_variable>
TEST_MACROS(); TEST_MACROS();
#ifndef _LIBCPP_HAS_NO_CXX20_COROUTINES
# include <coroutine>
TEST_MACROS();
#endif
#include <csetjmp> #include <csetjmp>
TEST_MACROS(); TEST_MACROS();
#include <csignal> #include <csignal>
TEST_MACROS(); TEST_MACROS();
#include <cstdarg> #include <cstdarg>
TEST_MACROS(); TEST_MACROS();
#include <cstdbool> #include <cstdbool>
TEST_MACROS(); TEST_MACROS();
▲ Show 20 Lines • Show All 217 Lines • ▼ Show 20 Lines
# include <wctype.h> # include <wctype.h>
TEST_MACROS(); TEST_MACROS();
#endif #endif
// experimental headers // experimental headers
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
# include <experimental/algorithm> # include <experimental/algorithm>
TEST_MACROS(); TEST_MACROS();
# if defined(__cpp_coroutines) # ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
# include <experimental/coroutine> # include <experimental/coroutine>
TEST_MACROS(); TEST_MACROS();
# endif # endif
# include <experimental/deque> # include <experimental/deque>
TEST_MACROS(); TEST_MACROS();
# ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY # ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
# include <experimental/filesystem> # include <experimental/filesystem>
TEST_MACROS(); TEST_MACROS();
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
#ifndef _LIBCPP_HAS_NO_LOCALIZATION #ifndef _LIBCPP_HAS_NO_LOCALIZATION
# include <codecvt> # include <codecvt>
#endif #endif
#include <compare> #include <compare>
#include <complex> #include <complex>
#include <complex.h> #include <complex.h>
#include <concepts> #include <concepts>
#include <condition_variable> #include <condition_variable>
#ifndef _LIBCPP_HAS_NO_CXX20_COROUTINES
# include <coroutine>
#endif
#include <csetjmp> #include <csetjmp>
#include <csignal> #include <csignal>
#include <cstdarg> #include <cstdarg>
#include <cstdbool> #include <cstdbool>
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines
#endif #endif
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
# include <wctype.h> # include <wctype.h>
#endif #endif
// experimental headers // experimental headers
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
# include <experimental/algorithm> # include <experimental/algorithm>
# if defined(__cpp_coroutines) # ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES
# include <experimental/coroutine> # include <experimental/coroutine>
# endif # endif
# include <experimental/deque> # include <experimental/deque>
# ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY # ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
# include <experimental/filesystem> # include <experimental/filesystem>
# endif # endif
# include <experimental/forward_list> # include <experimental/forward_list>
# include <experimental/functional> # include <experimental/functional>
Show All 31 Lines

libcxx/test/std/experimental/language.support/support.coroutines/end.to.end/generator.pass.cpp

Show All 10 Lines
// See https://llvm.org/PR33271 // See https://llvm.org/PR33271
// UNSUPPORTED: ubsan // UNSUPPORTED: ubsan
#include <experimental/coroutine> #include <experimental/coroutine>
#include <vector> #include <vector>
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "coroutine_types.h"
using namespace std::experimental;
template <typename Ty> struct generator {
struct promise_type {
Ty current_value;
std::experimental::suspend_always yield_value(Ty value) {
this->current_value = value;
return {};
}
std::experimental::suspend_always initial_suspend() { return {}; }
std::experimental::suspend_always final_suspend() noexcept { return {}; }
generator get_return_object() { return generator{this}; };
void return_void() {}
void unhandled_exception() {}
};
struct iterator {
std::experimental::coroutine_handle<promise_type> _Coro;
bool _Done;
iterator(std::experimental::coroutine_handle<promise_type> Coro, bool Done)
: _Coro(Coro), _Done(Done) {}
iterator &operator++() {
_Coro.resume();
_Done = _Coro.done();
return *this;
}
bool operator==(iterator const &_Right) const {
return _Done == _Right._Done;
}
bool operator!=(iterator const &_Right) const { return !(*this == _Right); }
Ty const &operator*() const { return _Coro.promise().current_value; }
Ty const *operator->() const { return &(operator*()); }
};
iterator begin() {
p.resume();
return {p, p.done()};
}
iterator end() { return {p, true}; }
generator(generator &&rhs) : p(rhs.p) { rhs.p = nullptr; }
~generator() {
if (p)
p.destroy();
}
private:
explicit generator(promise_type *p)
: p(std::experimental::coroutine_handle<promise_type>::from_promise(*p)) {}
std::experimental::coroutine_handle<promise_type> p;
};
struct minig { struct minig {
struct promise_type { struct promise_type {
int current_value; int current_value;
suspend_always yield_value(int value) { std::experimental::suspend_always yield_value(int value) {
this->current_value = value; this->current_value = value;
return {}; return {};
} }
suspend_always initial_suspend() { return {}; } std::experimental::suspend_always initial_suspend() { return {}; }
suspend_always final_suspend() noexcept { return {}; } std::experimental::suspend_always final_suspend() noexcept { return {}; }
minig get_return_object() { return minig{this}; }; minig get_return_object() { return minig{this}; };
void return_void() {} void return_void() {}
void unhandled_exception() {} void unhandled_exception() {}
}; };
bool move_next() { bool move_next() {
p.resume(); p.resume();
return !p.done(); return !p.done();
} }
int current_value() { return p.promise().current_value; } int current_value() { return p.promise().current_value; }
minig(minig &&rhs) : p(rhs.p) { rhs.p = nullptr; } minig(minig &&rhs) : p(rhs.p) { rhs.p = nullptr; }
~minig() { ~minig() {
if (p) if (p)
p.destroy(); p.destroy();
} }
private: private:
explicit minig(promise_type *p) explicit minig(promise_type *p)
: p(coroutine_handle<promise_type>::from_promise(*p)) {} : p(std::experimental::coroutine_handle<promise_type>::from_promise(*p)) {}
coroutine_handle<promise_type> p; std::experimental::coroutine_handle<promise_type> p;
}; };
minig mini_count(int n) { minig mini_count(int n) {
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
co_yield i; co_yield i;
} }
} }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// namespace std {
// template <class P> struct hash<coroutine_handle<P>>;
// }
#include <coroutine>
#include <type_traits>
#include <memory>
#include <utility>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
template <class C>
void do_test(int *LHSVal, int *RHSVal) {
const size_t ExpectLHS = std::hash<void*>{}((LHSVal));
const size_t ExpectRHS = std::hash<void*>{}((RHSVal));
const C LHS = C::from_address((LHSVal));
const C RHS = C::from_address((RHSVal));
const std::hash<C> h;
LIBCPP_ASSERT(h(LHS) == ExpectLHS);
LIBCPP_ASSERT(h(RHS) == ExpectRHS);
assert((h(LHS) == h(RHS)) == (LHSVal == RHSVal));
{
ASSERT_SAME_TYPE(decltype(h(LHS)), size_t);
ASSERT_NOEXCEPT(std::hash<C>{}(LHS));
}
}
int main(int, char**)
{
int i, j;
std::pair<int *, int *> const TestCases[] = {
{nullptr, nullptr},
{nullptr, &i},
{&i, &i},
{&i, &j}
};
for (auto& TC : TestCases) {
do_test<std::coroutine_handle<>>(TC.first, TC.second);
do_test<std::coroutine_handle<int>>(TC.first, TC.second);
}
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// constexpr explicit operator bool() const noexcept
#include <coroutine>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
template <class C>
constexpr bool do_test() {
static_assert(std::is_nothrow_constructible<bool, C>::value, "");
static_assert(!std::is_convertible<C, bool>::value, "");
{
constexpr C c;
static_assert(bool(c) == false, "");
}
{ // null case
const C c = {};
ASSERT_NOEXCEPT(bool(c));
assert(c.address() == nullptr);
assert(bool(c) == false);
}
{ // non-null case
char dummy = 42;
C c = C::from_address((void*)&dummy);
assert(c.address() == &dummy);
assert(bool(c) == true);
}
return true;
}
int main(int, char**)
{
do_test<std::coroutine_handle<>>();
do_test<std::coroutine_handle<int>>();
static_assert(do_test<std::coroutine_handle<>>());
static_assert(do_test<std::coroutine_handle<int>>());
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
#include <coroutine>
#include <type_traits>
#include <utility>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
template <class C>
void do_test(int *LHSVal, int *RHSVal) {
const C LHS = C::from_address(LHSVal);
const C RHS = C::from_address(RHSVal);
const bool ExpectIsEqual = (LHSVal == RHSVal);
assert((LHS == RHS) == ExpectIsEqual);
assert((RHS == LHS) == ExpectIsEqual);
assert((LHS != RHS) == !ExpectIsEqual);
assert((RHS != LHS) == !ExpectIsEqual);
{
static_assert(noexcept(LHS == RHS), "");
static_assert(noexcept(LHS != RHS), "");
ASSERT_SAME_TYPE(decltype(LHS == RHS), bool);
ASSERT_SAME_TYPE(decltype(LHS != RHS), bool);
}
}
int main(int, char**)
{
int i;
std::pair<int *, int *> const TestCases[] = {
{nullptr, nullptr},
{&i, &i},
{nullptr, &i},
{&i, nullptr}
};
for (auto& TC : TestCases) {
do_test<std::coroutine_handle<>>(TC.first, TC.second);
do_test<std::coroutine_handle<int>>(TC.first, TC.second);
}
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
#include <coroutine>
#include <type_traits>
#include <utility>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
template <class C>
void do_test(int *LHSVal, int *RHSVal) {
const C LHS = C::from_address(LHSVal);
const C RHS = C::from_address(RHSVal);
assert((LHS < RHS) == (LHSVal < RHSVal));
assert((RHS < LHS) == (RHSVal < LHSVal));
assert((LHS > RHS) == (LHSVal > RHSVal));
assert((RHS > LHS) == (RHSVal > LHSVal));
assert((LHS <= RHS) == (LHSVal <= RHSVal));
assert((RHS <= LHS) == (RHSVal <= LHSVal));
assert((LHS >= RHS) == (LHSVal >= RHSVal));
assert((RHS >= LHS) == (RHSVal >= LHSVal));
{
static_assert(noexcept(LHS < RHS), "");
static_assert(noexcept(LHS > RHS), "");
static_assert(noexcept(LHS <= RHS), "");
static_assert(noexcept(LHS >= RHS), "");
ASSERT_SAME_TYPE(decltype(LHS < RHS), bool);
ASSERT_SAME_TYPE(decltype(LHS > RHS), bool);
ASSERT_SAME_TYPE(decltype(LHS <= RHS), bool);
ASSERT_SAME_TYPE(decltype(LHS >= RHS), bool);
}
}
int main(int, char**)
{
int i;
std::pair<int *, int *> const TestCases[] = {
{nullptr, nullptr},
{&i, &i},
{nullptr, &i},
{&i, nullptr}
};
for (auto& TC : TestCases) {
do_test<std::coroutine_handle<>>(TC.first, TC.second);
do_test<std::coroutine_handle<int>>(TC.first, TC.second);
}
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// bool done() const
#include <coroutine>
#include <type_traits>
#include <memory>
#include <utility>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
template <class Promise>
void do_test(std::coroutine_handle<Promise> const& H) {
// FIXME Add a runtime test
{
ASSERT_SAME_TYPE(decltype(H.done()), bool);
LIBCPP_ASSERT_NOT_NOEXCEPT(H.done());
}
}
int main(int, char**)
{
do_test(std::coroutine_handle<>{});
do_test(std::coroutine_handle<int>{});
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// coroutine_handle& operator=(nullptr_t) noexcept
#include <coroutine>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
template <class C>
void do_test() {
int dummy = 42;
void* dummy_h = &dummy;
{
static_assert(std::is_nothrow_assignable<C&, std::nullptr_t>::value, "");
static_assert(!std::is_assignable<C&, void*>::value, "");
}
{
C c = C::from_address(dummy_h);
assert(c.address() == &dummy);
c = nullptr;
assert(c.address() == nullptr);
c = nullptr;
assert(c.address() == nullptr);
}
{
C c;
C& cr = (c = nullptr);
assert(&c == &cr);
}
}
int main(int, char**)
{
do_test<std::coroutine_handle<>>();
do_test<std::coroutine_handle<int>>();
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// constexpr coroutine_handle() noexcept
// constexpr coroutine_handle(nullptr_t) noexcept
#include <coroutine>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
template <class C>
constexpr bool do_test() {
static_assert(std::is_nothrow_constructible<C>::value, "");
static_assert(std::is_nothrow_constructible<C, std::nullptr_t>::value, "");
{
C c;
assert(c.address() == nullptr);
}
{
C c = C(nullptr);
assert(c.address() == nullptr);
}
return true;
}
int main(int, char**)
{
do_test<std::coroutine_handle<>>();
do_test<std::coroutine_handle<int>>();
static_assert(do_test<std::coroutine_handle<>>());
static_assert(do_test<std::coroutine_handle<int>>());
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// constexpr void* address() const noexcept
#include <coroutine>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
template <class C>
constexpr bool do_test() {
{
constexpr C c; ((void)c);
static_assert(c.address() == nullptr, "");
}
{
const C c = {}; ((void)c);
ASSERT_NOEXCEPT(c.address());
ASSERT_SAME_TYPE(decltype(c.address()), void*);
assert(c.address() == nullptr);
}
{
char dummy = 42;
C c = C::from_address((void*)&dummy);
assert(c.address() == &dummy);
}
return true;
}
int main(int, char**)
{
do_test<std::coroutine_handle<>>();
do_test<std::coroutine_handle<int>>();
static_assert(do_test<std::coroutine_handle<>>());
static_assert(do_test<std::coroutine_handle<int>>());
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// static coroutine_handle from_address(void*) noexcept
#include <coroutine>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
template <class C>
void do_test() {
{
C c = C::from_address(nullptr);
static_assert(noexcept(C::from_address(nullptr)), "");
static_assert(std::is_same<decltype(C::from_address(nullptr)), C>::value, "");
assert(c.address() == nullptr);
}
{
char dummy = 42;
C c = C::from_address((void*)&dummy);
assert(c.address() == &dummy);
}
{
C::from_address((int*)nullptr);
C::from_address((void*)nullptr);
C::from_address((char*)nullptr);
}
{
char dummy = 42;
C c = C::from_address(&dummy);
int* p = (int*)c.address();
std::coroutine_handle<> c2 = std::coroutine_handle<>::from_address(p);
assert(c2 == c);
}
}
int main(int, char**)
{
do_test<std::coroutine_handle<>>();
do_test<std::coroutine_handle<int>>();
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: ubsan
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// struct noop_coroutine_promise;
// using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
// noop_coroutine_handle noop_coroutine() noexcept;
#include <coroutine>
#include <cassert>
#include <type_traits>
#include "test_macros.h"
#if __has_builtin(__builtin_coro_noop)
static_assert(std::is_same<std::coroutine_handle<std::noop_coroutine_promise>, std::noop_coroutine_handle>::value, "");
static_assert(std::is_same<decltype(std::noop_coroutine()), std::noop_coroutine_handle>::value, "");
// template <> struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<>
// {
// // [coroutine.handle.noop.observers], observers
// constexpr explicit operator bool() const noexcept;
// constexpr bool done() const noexcept;
// // [coroutine.handle.noop.resumption], resumption
// constexpr void operator()() const noexcept;
// constexpr void resume() const noexcept;
// constexpr void destroy() const noexcept;
// // [coroutine.handle.noop.promise], promise access
// noop_coroutine_promise& promise() const noexcept;
// // [coroutine.handle.noop.address], address
// constexpr void* address() const noexcept;
int main(int, char**)
{
auto h = std::noop_coroutine();
std::coroutine_handle<> base = h;
assert(h);
assert(base);
assert(!h.done());
assert(!base.done());
h.resume();
h.destroy();
h();
static_assert(h.done() == false, "");
static_assert(h, "");
h.promise();
assert(h.address() == base.address());
assert(h==base);
assert(h.address() != nullptr);
assert(std::coroutine_handle<>::from_address(h.address()) == base);
return 0;
}
#else
int main(int, char**) { return 0; }
#endif // __has_builtin(__builtin_coro_noop)

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise>
// struct coroutine_handle<Promise>;
// Promise& promise() const
#include <coroutine>
#include <type_traits>
#include <memory>
#include <utility>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
struct MyCoro {
struct promise_type {
void unhandled_exception() {}
void return_void() {}
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
MyCoro get_return_object() {
do_runtime_test();
return {};
}
void do_runtime_test() {
// Test that a coroutine_handle<const T> can be created from a const
// promise_type and that it represents the same coroutine as
// coroutine_handle<T>
using CH = std::coroutine_handle<promise_type>;
using CCH = std::coroutine_handle<const promise_type>;
const auto &cthis = *this;
CH h = CH::from_promise(*this);
CCH h2 = CCH::from_promise(*this);
CCH h3 = CCH::from_promise(cthis);
assert(&h.promise() == this);
assert(&h2.promise() == this);
assert(&h3.promise() == this);
assert(h.address() == h2.address());
assert(h2.address() == h3.address());
}
};
};
MyCoro do_runtime_test() {
co_await std::suspend_never{};
}
template <class Promise>
void do_test(std::coroutine_handle<Promise>&& H) {
// FIXME Add a runtime test
{
ASSERT_SAME_TYPE(decltype(H.promise()), Promise&);
LIBCPP_ASSERT_NOT_NOEXCEPT(H.promise());
}
{
auto const& CH = H;
ASSERT_SAME_TYPE(decltype(CH.promise()), Promise&);
LIBCPP_ASSERT_NOT_NOEXCEPT(CH.promise());
}
}
int main(int, char**)
{
do_test(std::coroutine_handle<int>{});
do_test(std::coroutine_handle<const int>{});
do_runtime_test();
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// void destroy() const
#include <coroutine>
#include <type_traits>
#include <memory>
#include <utility>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
template <class H>
auto has_destroy_imp(H&& h, int) -> decltype(h.destroy(), std::true_type{});
template <class H>
auto has_destroy_imp(H&&, long) -> std::false_type;
template <class H>
constexpr bool has_destroy() {
return decltype(has_destroy_imp(std::declval<H>(), 0))::value;
}
template <class Promise>
void do_test(std::coroutine_handle<Promise>&& H) {
using HType = std::coroutine_handle<Promise>;
// FIXME Add a runtime test
{
ASSERT_SAME_TYPE(decltype(H.destroy()), void);
LIBCPP_ASSERT_NOT_NOEXCEPT(H.destroy());
static_assert(has_destroy<HType&>(), "");
static_assert(has_destroy<HType&&>(), "");
}
{
static_assert(has_destroy<HType const&>(), "");
static_assert(has_destroy<HType const&&>(), "");
}
}
int main(int, char**)
{
do_test(std::coroutine_handle<>{});
do_test(std::coroutine_handle<int>{});
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// <coroutine>
// template <class Promise = void>
// struct coroutine_handle;
// void operator()() const
// void resume() const
#include <coroutine>
#include <type_traits>
#include <memory>
#include <utility>
#include <cstdint>
#include <cassert>
#include "test_macros.h"
template <class H>
auto has_resume_imp(H&& h, int) -> decltype(h.resume(), std::true_type{});
template <class H>
auto has_resume_imp(H&&, long) -> std::false_type;
template <class H>
constexpr bool has_resume() {
return decltype(has_resume_imp(std::declval<H>(), 0))::value;
}
template <class H>
auto has_call_operator_imp(H&& h, int) -> decltype(h(), std::true_type{});
template <class H>
auto has_call_operator_imp(H&&, long) -> std::false_type;
template <class H>
constexpr bool has_call_operator() {
return decltype(has_call_operator_imp(std::declval<H>(), 0))::value;
}
template <class Promise>
void do_test(std::coroutine_handle<Promise>&& H) {
using HType = std::coroutine_handle<Promise>;
// FIXME Add a runtime test
{
ASSERT_SAME_TYPE(decltype(H.resume()), void);
ASSERT_SAME_TYPE(decltype(H()), void);
LIBCPP_ASSERT_NOT_NOEXCEPT(H.resume());
LIBCPP_ASSERT_NOT_NOEXCEPT(H());
static_assert(has_resume<HType&>(), "");
static_assert(has_resume<HType&&>(), "");
static_assert(has_call_operator<HType&>(), "");
static_assert(has_call_operator<HType&&>(), "");
}
{
static_assert(has_resume<HType const&>(), "");
static_assert(has_resume<HType const&&>(), "");
static_assert(has_call_operator<HType const&>(), "");
static_assert(has_call_operator<HType const&&>(), "");
}
}
int main(int, char**)
{
do_test(std::coroutine_handle<>{});
do_test(std::coroutine_handle<int>{});
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include "test_macros.h"
struct A {
using promise_type = A*;
};
struct B {};
struct C {};
template <>
struct std::coroutine_traits<A, int> {
using promise_type = int*;
};
template <class ...Args>
struct std::coroutine_traits<B, Args...> {
using promise_type = B*;
};
template <>
struct std::coroutine_traits<C> {
using promise_type = void;
};
template <class Expect, class T, class ...Args>
void check_type() {
using P = typename std::coroutine_traits<T, Args...>::promise_type ;
static_assert(std::is_same<P, Expect>::value, "");
};
int main(int, char**)
{
check_type<A*, A>();
check_type<int*, A, int>();
check_type<B*, B>();
check_type<void, C>();
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include "test_macros.h"
template <class T, class = typename T::promise_type>
constexpr bool has_promise_type(int) { return true; }
template <class>
constexpr bool has_promise_type(long) { return false; }
template <class T>
constexpr bool has_promise_type() { return has_promise_type<T>(0); }
struct A {
using promise_type = A*;
};
struct B {};
struct C {};
struct D {
private:
using promise_type = void;
};
struct E {};
template <>
struct std::coroutine_traits<A, int> {
using promise_type = int*;
};
template <class ...Args>
struct std::coroutine_traits<B, Args...> {
using promise_type = B*;
};
template <>
struct std::coroutine_traits<C> {
using promise_type = void;
};
template <class Expect, class T, class ...Args>
void check_type() {
using Traits = std::coroutine_traits<T, Args...>;
static_assert(has_promise_type<Traits>(), "");
static_assert(std::is_same<typename Traits::promise_type, Expect>::value, "");
}
template <class T, class ...Args>
void check_no_type() {
using Traits = std::coroutine_traits<T, Args...>;
static_assert(!has_promise_type<Traits>(), "");
}
int main(int, char**)
{
{
check_type<A*, A>();
check_type<int*, A, int>();
check_type<B*, B>();
check_type<void, C>();
}
{
check_no_type<D>();
check_no_type<E>();
check_no_type<C, int>();
}
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
TEST_SAFE_STATIC std::suspend_always safe_sa;
constexpr bool check_suspend_constexpr() {
std::suspend_always s{};
const std::suspend_always scopy(s);
std::suspend_always smove(std::move(s));
s = scopy;
s = std::move(smove);
return true;
}
template<class T>
constexpr bool test_trivial_awaitable_constexpr(bool expected) {
T t;
assert(t.await_ready() == expected);
t.await_suspend(nullptr);
t.await_resume();
return true;
}
int main(int, char**)
{
std::coroutine_handle<> h{};
std::suspend_always s{};
std::suspend_always const& cs = s;
{
ASSERT_NOEXCEPT(s.await_ready());
static_assert(std::is_same<decltype(s.await_ready()), bool>::value, "");
assert(s.await_ready() == false);
assert(cs.await_ready() == false);
}
{
ASSERT_NOEXCEPT(s.await_suspend(h));
static_assert(std::is_same<decltype(s.await_suspend(h)), void>::value, "");
s.await_suspend(h);
cs.await_suspend(h);
}
{
ASSERT_NOEXCEPT(s.await_resume());
static_assert(std::is_same<decltype(s.await_resume()), void>::value, "");
s.await_resume();
cs.await_resume();
}
{
static_assert(std::is_nothrow_default_constructible<std::suspend_always>::value, "");
static_assert(std::is_nothrow_copy_constructible<std::suspend_always>::value, "");
static_assert(std::is_nothrow_move_constructible<std::suspend_always>::value, "");
static_assert(std::is_nothrow_copy_assignable<std::suspend_always>::value, "");
static_assert(std::is_nothrow_move_assignable<std::suspend_always>::value, "");
static_assert(std::is_trivially_copyable<std::suspend_always>::value, "");
static_assert(check_suspend_constexpr(), "");
}
{
static_assert(test_trivial_awaitable_constexpr<std::suspend_always>(false));
}
return 0;
}

libcxx/test/std/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
// Test that the type 'std::suspend_never' is in the correct namespace
TEST_SAFE_STATIC std::suspend_never safe_sn;
constexpr std::suspend_never constexpr_sn;
constexpr bool check_suspend_constexpr() {
std::suspend_never s{};
const std::suspend_never scopy(s); ((void)scopy);
std::suspend_never smove(std::move(s)); ((void)smove);
s = scopy;
s = std::move(smove);
return true;
}
template<class T>
constexpr bool test_trivial_awaitable_constexpr(bool expected) {
T t;
assert(t.await_ready() == expected);
t.await_suspend(nullptr);
t.await_resume();
return true;
}
int main(int, char**)
{
using H = std::coroutine_handle<>;
using S = std::suspend_never;
H h{};
S s{};
S const& cs = s;
{
LIBCPP_STATIC_ASSERT(noexcept(s.await_ready()), "");
static_assert(std::is_same<decltype(s.await_ready()), bool>::value, "");
assert(s.await_ready() == true);
assert(cs.await_ready() == true);
}
{
LIBCPP_STATIC_ASSERT(noexcept(s.await_suspend(h)), "");
static_assert(std::is_same<decltype(s.await_suspend(h)), void>::value, "");
s.await_suspend(h);
cs.await_suspend(h);
}
{
LIBCPP_STATIC_ASSERT(noexcept(s.await_resume()), "");
static_assert(std::is_same<decltype(s.await_resume()), void>::value, "");
s.await_resume();
cs.await_resume();
}
{
static_assert(std::is_nothrow_default_constructible<std::suspend_never>::value, "");
static_assert(std::is_nothrow_copy_constructible<std::suspend_never>::value, "");
static_assert(std::is_nothrow_move_constructible<std::suspend_never>::value, "");
static_assert(std::is_nothrow_copy_assignable<std::suspend_never>::value, "");
static_assert(std::is_nothrow_move_assignable<std::suspend_never>::value, "");
static_assert(std::is_trivially_copyable<std::suspend_never>::value, "");
static_assert(check_suspend_constexpr(), "");
}
{
static_assert(test_trivial_awaitable_constexpr<std::suspend_never>(true));
}
{
// suppress unused warnings for the global constexpr test variable
((void)constexpr_sn);
}
return 0;
}

libcxx/test/std/language.support/support.coroutines/end.to.end/await_result.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include <cassert>
#include "test_macros.h"
struct coro_t {
struct promise_type {
coro_t get_return_object() {
std::coroutine_handle<promise_type>{};
return {};
}
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
static void unhandled_exception() {}
};
};
struct B {
~B() {}
bool await_ready() { return true; }
B await_resume() { return {}; }
template <typename F> void await_suspend(F) {}
};
struct A {
~A() {}
bool await_ready() { return true; }
int await_resume() { return 42; }
template <typename F> void await_suspend(F) {}
};
int last_value = -1;
void set_value(int x) {
last_value = x;
}
coro_t f(int n) {
if (n == 0) {
set_value(0);
co_return;
}
int val = co_await A{};
((void)val);
set_value(42);
}
coro_t g() { B val = co_await B{}; }
int main(int, char**) {
last_value = -1;
f(0);
assert(last_value == 0);
f(1);
assert(last_value == 42);
return 0;
}

libcxx/test/std/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// See https://llvm.org/PR33271
// UNSUPPORTED: ubsan
#include <coroutine>
#include <cassert>
#include "test_macros.h"
struct coro_t {
struct promise_type {
coro_t get_return_object() {
return std::coroutine_handle<promise_type>::from_promise(*this);
}
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() {}
};
coro_t(std::coroutine_handle<promise_type> hh) : h(hh) {}
std::coroutine_handle<promise_type> h;
};
struct NoSuspend {
bool await_ready() { return false; }
void await_resume() {}
template <typename F> bool await_suspend(F) { return false; }
};
struct DoSuspend {
bool await_ready() { return false; }
void await_resume() {}
template <typename F> bool await_suspend(F) { return true; }
};
bool f_started, f_resumed = false;
coro_t f() {
f_started = true;
co_await DoSuspend{};
f_resumed = true;
}
bool g_started, g_resumed = false;
coro_t g() {
g_started = true;
co_await NoSuspend{};
g_resumed = true;
}
int main(int, char**) {
assert(!f_started && !f_resumed && !g_started && !g_resumed);
auto fret = f();
assert(f_started && !f_resumed);
fret.h.destroy();
assert(f_started && !f_resumed);
g();
assert(g_started && g_resumed);
return 0;
}

libcxx/test/std/language.support/support.coroutines/end.to.end/expected.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include <cassert>
#include <memory>
#include "test_macros.h"
struct error_tag { };
template <typename T, typename Error = int>
struct expected {
struct Data {
Data() : val(), error() { }
Data(T v, Error e) : val(v), error(e) { }
T val;
Error error;
};
std::shared_ptr<Data> data;
expected(T val) : data(std::make_shared<Data>(val, Error())) {}
expected(error_tag, Error error) : data(std::make_shared<Data>(T(), error)) {}
expected(std::shared_ptr<Data> p) : data(p) {}
struct promise_type {
std::shared_ptr<Data> data;
expected get_return_object() { data = std::make_shared<Data>(); return {data}; }
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_value(T v) { data->val = v; data->error = {}; }
void unhandled_exception() {}
};
bool await_ready() { return !data->error; }
T await_resume() { return data->val; }
void await_suspend(std::coroutine_handle<promise_type> h) {
h.promise().data->error = data->error;
h.destroy();
}
T const& value() { return data->val; }
Error const& error() { return data->error; }
};
expected<int> g() { return {0}; }
expected<int> h() { return {error_tag{}, 42}; }
extern "C" void print(int);
bool f1_started, f1_resumed = false;
expected<int> f1() {
f1_started = true;
(void)(co_await g());
f1_resumed = true;
co_return 100;
}
bool f2_started, f2_resumed = false;
expected<int> f2() {
f2_started = true;
(void)(co_await h());
f2_resumed = true;
co_return 200;
}
int main(int, char**) {
auto c1 = f1();
assert(f1_started && f1_resumed);
assert(c1.value() == 100);
assert(c1.error() == 0);
auto c2 = f2();
assert(f2_started && !f2_resumed);
assert(c2.value() == 0);
assert(c2.error() == 42);
return 0;
}

libcxx/test/std/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include <cassert>
#include "test_macros.h"
int alive = 0;
int ctor_called = 0;
int dtor_called = 0;
void reset() {
assert(alive == 0);
alive = 0;
ctor_called = 0;
dtor_called = 0;
}
struct Noisy {
Noisy() { ++alive; ++ctor_called; }
~Noisy() { --alive; ++dtor_called; }
Noisy(Noisy const&) = delete;
};
struct Bug {
bool await_ready() { return true; }
void await_suspend(std::coroutine_handle<>) {}
Noisy await_resume() { return {}; }
};
struct coro2 {
struct promise_type {
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
coro2 get_return_object() { return {}; }
void return_void() {}
Bug yield_value(int) { return {}; }
void unhandled_exception() {}
};
};
// Checks that destructors are correctly invoked for the object returned by
// coawait.
coro2 a() {
reset();
{
auto x = co_await Bug{};
assert(alive == 1);
assert(ctor_called == 1);
assert(dtor_called == 0);
((void)x);
}
assert(alive == 0);
assert(dtor_called == 1);
}
coro2 b() {
reset();
{
co_await Bug{};
assert(ctor_called == 1);
assert(dtor_called == 1);
assert(alive == 0);
}
assert(ctor_called == 1);
assert(dtor_called == 1);
assert(alive == 0);
}
coro2 c() {
reset();
{
auto x = co_yield 42;
assert(alive == 1);
assert(ctor_called == 1);
assert(dtor_called == 0);
}
assert(alive == 0);
assert(ctor_called == 1);
assert(dtor_called == 1);
}
coro2 d() {
reset();
{
co_yield 42;
assert(ctor_called == 1);
assert(dtor_called == 1);
assert(alive == 0);
}
assert(alive == 0);
assert(ctor_called == 1);
assert(dtor_called == 1);
}
int main(int, char**) {
a();
b();
c();
d();
return 0;
}

libcxx/test/std/language.support/support.coroutines/end.to.end/generator.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
// See https://llvm.org/PR33271
// UNSUPPORTED: ubsan
#include <coroutine>
#include <vector>
#include <cassert>
#include "test_macros.h"
template <typename Ty> struct generator {
struct promise_type {
Ty current_value;
std::suspend_always yield_value(Ty value) {
this->current_value = value;
return {};
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
generator get_return_object() { return generator{this}; };
void return_void() {}
void unhandled_exception() {}
};
struct iterator {
std::coroutine_handle<promise_type> Coro_;
bool Done_;
iterator(std::coroutine_handle<promise_type> Coro, bool Done)
: Coro_(Coro), Done_(Done) {}
iterator &operator++() {
Coro_.resume();
Done_ = Coro_.done();
return *this;
}
bool operator==(iterator const &_Right) const {
return Done_ == _Right.Done_;
}
bool operator!=(iterator const &_Right) const { return !(*this == _Right); }
Ty const &operator*() const { return Coro_.promise().current_value; }
Ty const *operator->() const { return &(operator*()); }
};
iterator begin() {
p.resume();
return {p, p.done()};
}
iterator end() { return {p, true}; }
generator(generator &&rhs) : p(rhs.p) { rhs.p = nullptr; }
~generator() {
if (p)
p.destroy();
}
private:
explicit generator(promise_type *promise)
: p(std::coroutine_handle<promise_type>::from_promise(*promise)) {}
std::coroutine_handle<promise_type> p;
};
struct minig {
struct promise_type {
int current_value;
std::suspend_always yield_value(int value) {
this->current_value = value;
return {};
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
minig get_return_object() { return minig{this}; };
void return_void() {}
void unhandled_exception() {}
};
bool move_next() {
p.resume();
return !p.done();
}
int current_value() { return p.promise().current_value; }
minig(minig &&rhs) : p(rhs.p) { rhs.p = nullptr; }
~minig() {
if (p)
p.destroy();
}
private:
explicit minig(promise_type *promise)
: p(std::coroutine_handle<promise_type>::from_promise(*promise)) {}
std::coroutine_handle<promise_type> p;
};
minig mini_count(int n) {
for (int i = 0; i < n; i++) {
co_yield i;
}
}
generator<int> count(int n) {
for (int i = 0; i < n; ++i)
co_yield i;
}
generator<int> range(int from, int n) {
for (int i = from; i < n; ++i)
co_yield i;
}
void test_count() {
const std::vector<int> expect = {0, 1, 2, 3, 4};
std::vector<int> got;
for (auto x : count(5))
got.push_back(x);
assert(expect == got);
}
void test_range() {
int sum = 0;
for (auto v: range(1, 20))
sum += v;
assert(sum == 190);
}
void test_mini_generator() {
int sum = 0;
auto g = mini_count(5);
while (g.move_next()) {
sum += g.current_value();
}
assert(sum == 10);
}
int main(int, char**) {
test_count();
test_range();
test_mini_generator();
return 0;
}

libcxx/test/std/language.support/support.coroutines/end.to.end/go.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <cassert>
#include <coroutine>
#include <memory>
#include "test_macros.h"
bool cancel = false;
struct goroutine
{
static int const N = 10;
static int count;
static std::coroutine_handle<> stack[N];
static void schedule(std::coroutine_handle<>& rh)
{
assert(count < N);
stack[count++] = rh;
rh = nullptr;
}
~goroutine() {}
static void go(goroutine) {}
static void run_one()
{
assert(count > 0);
stack[--count]();
}
struct promise_type
{
std::suspend_never initial_suspend() {
return {};
}
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
goroutine get_return_object() {
return{};
}
void unhandled_exception() {}
};
};
int goroutine::count;
std::coroutine_handle<> goroutine::stack[N];
std::coroutine_handle<goroutine::promise_type> workaround;
class channel;
struct push_awaiter {
channel* ch;
bool await_ready() {return false; }
void await_suspend(std::coroutine_handle<> rh);
void await_resume() {}
};
struct pull_awaiter {
channel * ch;
bool await_ready();
void await_suspend(std::coroutine_handle<> rh);
int await_resume();
};
class channel
{
using T = int;
friend struct push_awaiter;
friend struct pull_awaiter;
T const* pvalue = nullptr;
std::coroutine_handle<> reader = nullptr;
std::coroutine_handle<> writer = nullptr;
public:
push_awaiter push(T const& value)
{
assert(pvalue == nullptr);
assert(!writer);
pvalue = &value;
return { this };
}
pull_awaiter pull()
{
assert(!reader);
return { this };
}
void sync_push(T const& value)
{
assert(!pvalue);
pvalue = &value;
assert(reader);
reader();
assert(!pvalue);
reader = nullptr;
}
auto sync_pull()
{
while (!pvalue) goroutine::run_one();
auto result = *pvalue;
pvalue = nullptr;
if (writer)
{
auto wr = writer;
writer = nullptr;
wr();
}
return result;
}
};
void push_awaiter::await_suspend(std::coroutine_handle<> rh)
{
ch->writer = rh;
if (ch->reader) goroutine::schedule(ch->reader);
}
bool pull_awaiter::await_ready() {
return !!ch->writer;
}
void pull_awaiter::await_suspend(std::coroutine_handle<> rh) {
ch->reader = rh;
}
int pull_awaiter::await_resume() {
auto result = *ch->pvalue;
ch->pvalue = nullptr;
if (ch->writer) {
//goroutine::schedule(ch->writer);
auto wr = ch->writer;
ch->writer = nullptr;
wr();
}
return result;
}
goroutine pusher(channel& left, channel& right)
{
for (;;) {
auto val = co_await left.pull();
co_await right.push(val + 1);
}
}
const int N = 100;
auto c = std::make_unique<channel[]>(N + 1);
int main(int, char**) {
for (int i = 0; i < N; ++i)
pusher(c[i], c[i + 1]);
c[0].sync_push(0);
int result = c[N].sync_pull();
assert(result == 100);
return 0;
}

libcxx/test/std/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include <cassert>
#include "test_macros.h"
// This file tests, multishot, movable std::function like thing using coroutine
// for compile-time type erasure and unerasure.
template <typename R> struct func {
struct Input {R a, b;};
struct promise_type {
Input* I;
R result;
func get_return_object() { return {this}; }
std::suspend_always initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
template <typename F>
std::suspend_always yield_value(F&& f) {
result = f(I->a, I->b);
return {};
}
void unhandled_exception() {}
};
R operator()(Input I) {
h.promise().I = &I;
h.resume();
R result = h.promise().result;
return result;
};
func() {}
func(func &&rhs) : h(rhs.h) { rhs.h = nullptr; }
func(func const &) = delete;
func &operator=(func &&rhs) {
if (this != &rhs) {
if (h)
h.destroy();
h = rhs.h;
rhs.h = nullptr;
}
return *this;
}
template <typename F> static func Create(F f) {
for (;;) {
co_yield f;
}
}
template <typename F> func(F f) : func(Create(f)) {}
~func() {
if (h)
h.destroy();
}
private:
func(promise_type *promise)
: h(std::coroutine_handle<promise_type>::from_promise(*promise)) {}
std::coroutine_handle<promise_type> h;
};
int Do(int acc, int n, func<int> f) {
for (int i = 0; i < n; ++i)
acc = f({acc, i});
return acc;
}
int main(int, char**) {
int result = Do(1, 10, [](int a, int b) {return a + b;});
assert(result == 46);
return 0;
}

libcxx/test/std/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines
#include <coroutine>
#include <vector>
#include <cassert>
#include "test_macros.h"
// This file tests, one shot, movable std::function like thing using coroutine
// for compile-time type erasure and unerasure.
template <typename R> struct func {
struct promise_type {
R result;
func get_return_object() { return {this}; }
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_value(R v) { result = v; }
void unhandled_exception() {}
};
R operator()() {
h.resume();
R result = h.promise().result;
h.destroy();
h = nullptr;
return result;
};
func() {}
func(func &&rhs) : h(rhs.h) { rhs.h = nullptr; }
func(func const &) = delete;
func &operator=(func &&rhs) {
if (this != &rhs) {
if (h)
h.destroy();
h = rhs.h;
rhs.h = nullptr;
}
return *this;
}
template <typename F> static func Create(F f) { co_return f(); }
template <typename F> func(F f) : func(Create(f)) {}
~func() {
if (h)
h.destroy();
}
private:
func(promise_type *promise)
: h(std::coroutine_handle<promise_type>::from_promise(*promise)) {}
std::coroutine_handle<promise_type> h;
};
int main(int, char**) {
func<int> f = func<int>::Create([]() { return 44; });
assert(f() == 44);
return 0;
}

libcxx/test/std/language.support/support.limits/support.limits.general/coroutine.version.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// WARNING: This test was generated by generate_feature_test_macro_components.py
// and should not be edited manually.
//
// clang-format off
// <coroutine>
// Test the feature test macros defined by <coroutine>
/* Constant Value
__cpp_lib_coroutine 201902L [C++20]
*/
#include <coroutine>
#include "test_macros.h"
#if TEST_STD_VER < 14
# ifdef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should not be defined before c++20"
# endif
#elif TEST_STD_VER == 14
# ifdef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should not be defined before c++20"
# endif
#elif TEST_STD_VER == 17
# ifdef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should not be defined before c++20"
# endif
#elif TEST_STD_VER == 20
# ifndef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should be defined in c++20"
# endif
# if __cpp_lib_coroutine != 201902L
# error "__cpp_lib_coroutine should have the value 201902L in c++20"
# endif
#elif TEST_STD_VER > 20
# ifndef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should be defined in c++2b"
# endif
# if __cpp_lib_coroutine != 201902L
# error "__cpp_lib_coroutine should have the value 201902L in c++2b"
# endif
#endif // TEST_STD_VER > 20
int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

Show First 20 Lines • Show All 2,456 Lines • ▼ Show 20 Lines
# error "__cpp_lib_constexpr_vector should have the value 201907L in c++20" # error "__cpp_lib_constexpr_vector should have the value 201907L in c++20"
# endif # endif
# else // _LIBCPP_VERSION # else // _LIBCPP_VERSION
# ifdef __cpp_lib_constexpr_vector # ifdef __cpp_lib_constexpr_vector
# error "__cpp_lib_constexpr_vector should not be defined because it is unimplemented in libc++!" # error "__cpp_lib_constexpr_vector should not be defined because it is unimplemented in libc++!"
# endif # endif
# endif # endif
# if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_coroutine # ifndef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should be defined in c++20" # error "__cpp_lib_coroutine should be defined in c++20"
# endif # endif
# if __cpp_lib_coroutine != 201902L # if __cpp_lib_coroutine != 201902L
# error "__cpp_lib_coroutine should have the value 201902L in c++20" # error "__cpp_lib_coroutine should have the value 201902L in c++20"
# endif # endif
# else // _LIBCPP_VERSION
# ifdef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should not be defined because it is unimplemented in libc++!"
# endif
# endif
# if TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L # if TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
# ifndef __cpp_lib_destroying_delete # ifndef __cpp_lib_destroying_delete
# error "__cpp_lib_destroying_delete should be defined in c++20" # error "__cpp_lib_destroying_delete should be defined in c++20"
# endif # endif
# if __cpp_lib_destroying_delete != 201806L # if __cpp_lib_destroying_delete != 201806L
# error "__cpp_lib_destroying_delete should have the value 201806L in c++20" # error "__cpp_lib_destroying_delete should have the value 201806L in c++20"
# endif # endif
▲ Show 20 Lines • Show All 1,123 Lines • ▼ Show 20 Lines
# error "__cpp_lib_constexpr_vector should have the value 201907L in c++2b" # error "__cpp_lib_constexpr_vector should have the value 201907L in c++2b"
# endif # endif
# else // _LIBCPP_VERSION # else // _LIBCPP_VERSION
# ifdef __cpp_lib_constexpr_vector # ifdef __cpp_lib_constexpr_vector
# error "__cpp_lib_constexpr_vector should not be defined because it is unimplemented in libc++!" # error "__cpp_lib_constexpr_vector should not be defined because it is unimplemented in libc++!"
# endif # endif
# endif # endif
# if !defined(_LIBCPP_VERSION)
# ifndef __cpp_lib_coroutine # ifndef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should be defined in c++2b" # error "__cpp_lib_coroutine should be defined in c++2b"
# endif # endif
# if __cpp_lib_coroutine != 201902L # if __cpp_lib_coroutine != 201902L
# error "__cpp_lib_coroutine should have the value 201902L in c++2b" # error "__cpp_lib_coroutine should have the value 201902L in c++2b"
# endif # endif
# else // _LIBCPP_VERSION
# ifdef __cpp_lib_coroutine
# error "__cpp_lib_coroutine should not be defined because it is unimplemented in libc++!"
# endif
# endif
# if TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L # if TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
# ifndef __cpp_lib_destroying_delete # ifndef __cpp_lib_destroying_delete
# error "__cpp_lib_destroying_delete should be defined in c++2b" # error "__cpp_lib_destroying_delete should be defined in c++2b"
# endif # endif
# if __cpp_lib_destroying_delete != 201806L # if __cpp_lib_destroying_delete != 201806L
# error "__cpp_lib_destroying_delete should have the value 201806L in c++2b" # error "__cpp_lib_destroying_delete should have the value 201806L in c++2b"
# endif # endif
▲ Show 20 Lines • Show All 782 Lines • Show Last 20 Lines

libcxx/test/support/coroutine_types.h

  • This file was deleted.
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// 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 SUPPORT_COROUTINE_TYPES_H
#define SUPPORT_COROUTINE_TYPES_H
#include <experimental/coroutine>
template <typename Ty> struct generator {
struct promise_type {
Ty current_value;
std::experimental::suspend_always yield_value(Ty value) {
this->current_value = value;
return {};
}
std::experimental::suspend_always initial_suspend() { return {}; }
std::experimental::suspend_always final_suspend() noexcept { return {}; }
generator get_return_object() { return generator{this}; };
void return_void() {}
void unhandled_exception() {}
};
struct iterator {
std::experimental::coroutine_handle<promise_type> _Coro;
bool _Done;
iterator(std::experimental::coroutine_handle<promise_type> Coro, bool Done)
: _Coro(Coro), _Done(Done) {}
iterator &operator++() {
_Coro.resume();
_Done = _Coro.done();
return *this;
}
bool operator==(iterator const &_Right) const {
return _Done == _Right._Done;
}
bool operator!=(iterator const &_Right) const { return !(*this == _Right); }
Ty const &operator*() const { return _Coro.promise().current_value; }
Ty const *operator->() const { return &(operator*()); }
};
iterator begin() {
p.resume();
return {p, p.done()};
}
iterator end() { return {p, true}; }
generator(generator &&rhs) : p(rhs.p) { rhs.p = nullptr; }
~generator() {
if (p)
p.destroy();
}
private:
explicit generator(promise_type *p)
: p(std::experimental::coroutine_handle<promise_type>::from_promise(*p)) {}
std::experimental::coroutine_handle<promise_type> p;
};
#endif // SUPPORT_COROUTINE_TYPES_H

libcxx/utils/generate_feature_test_macro_components.py

Show First 20 Lines • Show All 252 Lines • ▼ Show 20 Linesfeature_test_macros = [ add_version_header(x) for x in [
"name": "__cpp_lib_constexpr_vector", "name": "__cpp_lib_constexpr_vector",
"values": { "c++20": 201907 }, "values": { "c++20": 201907 },
"headers": ["vector"], "headers": ["vector"],
"unimplemented": True, "unimplemented": True,
}, { }, {
"name": "__cpp_lib_coroutine", "name": "__cpp_lib_coroutine",
"values": { "c++20": 201902 }, "values": { "c++20": 201902 },
"headers": ["coroutine"], "headers": ["coroutine"],
"unimplemented": True,
}, { }, {
"name": "__cpp_lib_destroying_delete", "name": "__cpp_lib_destroying_delete",
"values": { "c++20": 201806 }, "values": { "c++20": 201806 },
"headers": ["new"], "headers": ["new"],
"test_suite_guard": "TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L", "test_suite_guard": "TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
"libcxx_guard": "_LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L", "libcxx_guard": "_LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
}, { }, {
"name": "__cpp_lib_enable_shared_from_this", "name": "__cpp_lib_enable_shared_from_this",
▲ Show 20 Lines • Show All 847 Lines • Show Last 20 Lines

libcxx/utils/generate_header_inclusion_tests.py

Show All 23 Lines
# #
mandatory_inclusions = { mandatory_inclusions = {
"algorithm": ["initializer_list"], "algorithm": ["initializer_list"],
"array": ["compare", "initializer_list"], "array": ["compare", "initializer_list"],
"bitset": ["iosfwd", "string"], "bitset": ["iosfwd", "string"],
"chrono": ["compare"], "chrono": ["compare"],
"cinttypes": ["cstdint"], "cinttypes": ["cstdint"],
"complex.h": ["complex"], "complex.h": ["complex"],
# TODO "coroutine": ["compare"], "coroutine": ["compare"],
"deque": ["compare", "initializer_list"], "deque": ["compare", "initializer_list"],
"filesystem": ["compare"], "filesystem": ["compare"],
"forward_list": ["compare", "initializer_list"], "forward_list": ["compare", "initializer_list"],
"ios": ["iosfwd"], "ios": ["iosfwd"],
"iostream": ["ios", "istream", "ostream", "streambuf"], "iostream": ["ios", "istream", "ostream", "streambuf"],
"iterator": ["compare", "concepts"], "iterator": ["compare", "concepts"],
"list": ["compare", "initializer_list"], "list": ["compare", "initializer_list"],
"map": ["compare", "initializer_list"], "map": ["compare", "initializer_list"],
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

libcxx/utils/generate_header_tests.py

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesheader_markup = {
"streambuf": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"], "streambuf": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
"strstream": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"], "strstream": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
"wctype.h": ["ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS"], "wctype.h": ["ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS"],
"cwctype": ["ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS"], "cwctype": ["ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS"],
"cwchar": ["ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS"], "cwchar": ["ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS"],
"wchar.h": ["ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS"], "wchar.h": ["ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS"],
"experimental/coroutine": ["if defined(__cpp_coroutines)"], "experimental/coroutine": ["ifndef _LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES"],
"coroutine": ["ifndef _LIBCPP_HAS_NO_CXX20_COROUTINES"],
"experimental/regex": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"], "experimental/regex": ["ifndef _LIBCPP_HAS_NO_LOCALIZATION"],
} }
allowed_extensions = ['', '.h'] allowed_extensions = ['', '.h']
indent_width = 4 indent_width = 4
begin_pattern = """\ begin_pattern = """\
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

libcxx/utils/libcxx/test/features.py

Show All 33 LinesDEFAULT_FEATURES = [
Feature(name='has-fblocks', when=lambda cfg: hasCompileFlag(cfg, '-fblocks')), Feature(name='has-fblocks', when=lambda cfg: hasCompileFlag(cfg, '-fblocks')),
Feature(name='-fsized-deallocation', when=lambda cfg: hasCompileFlag(cfg, '-fsized-deallocation')), Feature(name='-fsized-deallocation', when=lambda cfg: hasCompileFlag(cfg, '-fsized-deallocation')),
Feature(name='-faligned-allocation', when=lambda cfg: hasCompileFlag(cfg, '-faligned-allocation')), Feature(name='-faligned-allocation', when=lambda cfg: hasCompileFlag(cfg, '-faligned-allocation')),
Feature(name='fdelayed-template-parsing', when=lambda cfg: hasCompileFlag(cfg, '-fdelayed-template-parsing')), Feature(name='fdelayed-template-parsing', when=lambda cfg: hasCompileFlag(cfg, '-fdelayed-template-parsing')),
Feature(name='libcpp-no-if-constexpr', when=lambda cfg: '__cpp_if_constexpr' not in featureTestMacros(cfg)), Feature(name='libcpp-no-if-constexpr', when=lambda cfg: '__cpp_if_constexpr' not in featureTestMacros(cfg)),
Feature(name='libcpp-no-structured-bindings', when=lambda cfg: '__cpp_structured_bindings' not in featureTestMacros(cfg)), Feature(name='libcpp-no-structured-bindings', when=lambda cfg: '__cpp_structured_bindings' not in featureTestMacros(cfg)),
Feature(name='libcpp-no-concepts', when=lambda cfg: featureTestMacros(cfg).get('__cpp_concepts', 0) < 201907), Feature(name='libcpp-no-concepts', when=lambda cfg: featureTestMacros(cfg).get('__cpp_concepts', 0) < 201907),
Feature(name='libcpp-no-coroutines', when=lambda cfg: featureTestMacros(cfg).get('__cpp_impl_coroutine', 0) < 201902),
Feature(name='has-fobjc-arc', when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc') and Feature(name='has-fobjc-arc', when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc') and
sys.platform.lower().strip() == 'darwin'), # TODO: this doesn't handle cross-compiling to Apple platforms. sys.platform.lower().strip() == 'darwin'), # TODO: this doesn't handle cross-compiling to Apple platforms.
Feature(name='objective-c++', when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc')), Feature(name='objective-c++', when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc')),
Feature(name='no-noexcept-function-type', when=lambda cfg: featureTestMacros(cfg).get('__cpp_noexcept_function_type', 0) < 201510), Feature(name='no-noexcept-function-type', when=lambda cfg: featureTestMacros(cfg).get('__cpp_noexcept_function_type', 0) < 201510),
Feature(name='non-lockfree-atomics', Feature(name='non-lockfree-atomics',
when=lambda cfg: sourceBuilds(cfg, """ when=lambda cfg: sourceBuilds(cfg, """
#include <atomic> #include <atomic>
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines
libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp