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