1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // UNSUPPORTED: c++03, c++11, c++14, c++17
10
11 #include <coroutine>
12 #include <cassert>
13 #include <memory>
14
15 #include "test_macros.h"
16
17 struct error_tag { };
18
19 template <typename T, typename Error = int>
20 struct expected {
21
22 struct Data {
Dataexpected::Data23 Data() : val(), error() { }
Dataexpected::Data24 Data(T v, Error e) : val(v), error(e) { }
25 T val;
26 Error error;
27 };
28 std::shared_ptr<Data> data;
29
expectedexpected30 expected(T val) : data(std::make_shared<Data>(val, Error())) {}
expectedexpected31 expected(error_tag, Error error) : data(std::make_shared<Data>(T(), error)) {}
expectedexpected32 expected(std::shared_ptr<Data> p) : data(p) {}
33
34 struct promise_type {
35 std::shared_ptr<Data> data;
get_return_objectexpected::promise_type36 expected get_return_object() { data = std::make_shared<Data>(); return {data}; }
initial_suspendexpected::promise_type37 std::suspend_never initial_suspend() { return {}; }
final_suspendexpected::promise_type38 std::suspend_never final_suspend() noexcept { return {}; }
return_valueexpected::promise_type39 void return_value(T v) { data->val = v; data->error = {}; }
unhandled_exceptionexpected::promise_type40 void unhandled_exception() {}
41 };
42
await_readyexpected43 bool await_ready() { return !data->error; }
await_resumeexpected44 T await_resume() { return data->val; }
await_suspendexpected45 void await_suspend(std::coroutine_handle<promise_type> h) {
46 h.promise().data->error = data->error;
47 h.destroy();
48 }
49
valueexpected50 T const& value() { return data->val; }
errorexpected51 Error const& error() { return data->error; }
52 };
53
g()54 expected<int> g() { return {0}; }
h()55 expected<int> h() { return {error_tag{}, 42}; }
56
57 extern "C" void print(int);
58
59 bool f1_started, f1_resumed = false;
f1()60 expected<int> f1() {
61 f1_started = true;
62 (void)(co_await g());
63 f1_resumed = true;
64 co_return 100;
65 }
66
67 bool f2_started, f2_resumed = false;
f2()68 expected<int> f2() {
69 f2_started = true;
70 (void)(co_await h());
71 f2_resumed = true;
72 co_return 200;
73 }
74
main(int,char **)75 int main(int, char**) {
76 auto c1 = f1();
77 assert(f1_started && f1_resumed);
78 assert(c1.value() == 100);
79 assert(c1.error() == 0);
80
81 auto c2 = f2();
82 assert(f2_started && !f2_resumed);
83 assert(c2.value() == 0);
84 assert(c2.error() == 42);
85
86 return 0;
87 }
88