xref: /llvm-project/clang-tools-extra/test/clang-tidy/checkers/bugprone/exception-escape-coro.cpp (revision ff40c34881772e0641027327cd1791f4acacf6ff)

// RUN: %check_clang_tidy -std=c++20 %s bugprone-exception-escape %t -- \
// RUN:     -- -fexceptions

namespace std {

template <class Ret, typename... T> struct coroutine_traits {
  using promise_type = typename Ret::promise_type;
};

template <class Promise = void> struct coroutine_handle {
  static coroutine_handle from_address(void *) noexcept;
  static coroutine_handle from_promise(Promise &promise);
  constexpr void *address() const noexcept;
};

template <> struct coroutine_handle<void> {
  template <class PromiseType>
  coroutine_handle(coroutine_handle<PromiseType>) noexcept;
  static coroutine_handle from_address(void *);
  constexpr void *address() const noexcept;
};

struct suspend_always {
  bool await_ready() noexcept { return false; }
  void await_suspend(coroutine_handle<>) noexcept {}
  void await_resume() noexcept {}
};

struct suspend_never {
  bool await_ready() noexcept { return true; }
  void await_suspend(coroutine_handle<>) noexcept {}
  void await_resume() noexcept {}
};

} // namespace std

template <typename Task, typename T, bool ThrowInPromiseConstructor,
          bool ThrowInInitialSuspend, bool ThrowInGetReturnObject,
          bool ThrowInUnhandledException, bool RethrowInUnhandledException>
struct Promise;

template <
    typename T, bool ThrowInTaskConstructor = false,
    bool ThrowInPromiseConstructor = false, bool ThrowInInitialSuspend = false,
    bool ThrowInGetReturnObject = false, bool ThrowInUnhandledException = false,
    bool RethrowInUnhandledException = false>
struct Task {
  using promise_type =
      Promise<Task, T, ThrowInPromiseConstructor, ThrowInInitialSuspend,
              ThrowInGetReturnObject, ThrowInUnhandledException, RethrowInUnhandledException>;

  explicit Task(promise_type &p) {
    if constexpr (ThrowInTaskConstructor) {
      throw 1;
    }

    p.return_val = this;
  }

  bool await_ready() { return true; }

  void await_suspend(std::coroutine_handle<> h) {}

  void await_resume() {}

  T value;
};

template <bool ThrowInTaskConstructor, bool ThrowInPromiseConstructor,
          bool ThrowInInitialSuspend, bool ThrowInGetReturnObject,
          bool ThrowInUnhandledException, bool RethrowInUnhandledException>
struct Task<void, ThrowInTaskConstructor, ThrowInPromiseConstructor,
            ThrowInInitialSuspend, ThrowInGetReturnObject,
            ThrowInUnhandledException, RethrowInUnhandledException> {
  using promise_type =
      Promise<Task, void, ThrowInPromiseConstructor, ThrowInInitialSuspend,
              ThrowInGetReturnObject, ThrowInUnhandledException, RethrowInUnhandledException>;

  explicit Task(promise_type &p) {
    if constexpr (ThrowInTaskConstructor) {
      throw 1;
    }

    p.return_val = this;
  }

  bool await_ready() { return true; }

  void await_suspend(std::coroutine_handle<> h) {}

  void await_resume() {}
};

template <typename Task, typename T, bool ThrowInPromiseConstructor,
          bool ThrowInInitialSuspend, bool ThrowInGetReturnObject,
          bool ThrowInUnhandledException, bool RethrowInUnhandledException>
struct Promise {
  Promise() {
    if constexpr (ThrowInPromiseConstructor) {
      throw 1;
    }
  }

  Task get_return_object() {
    if constexpr (ThrowInGetReturnObject) {
      throw 1;
    }

    return Task{*this};
  }

  std::suspend_never initial_suspend() const {
    if constexpr (ThrowInInitialSuspend) {
      throw 1;
    }

    return {};
  }

  std::suspend_never final_suspend() const noexcept { return {}; }

  template <typename U> void return_value(U &&val) {
    return_val->value = static_cast<U &&>(val);
  }

  template <typename U> std::suspend_never yield_value(U &&val) {
    return_val->value = static_cast<U &&>(val);
    return {};
  }

  void unhandled_exception() {
    if constexpr (ThrowInUnhandledException) {
      throw 1;
    } else if constexpr (RethrowInUnhandledException) {
      throw;
    }
  }

  Task *return_val;
};

template <typename Task, bool ThrowInPromiseConstructor,
          bool ThrowInInitialSuspend, bool ThrowInGetReturnObject,
          bool ThrowInUnhandledException, bool RethrowInUnhandledException>
struct Promise<Task, void, ThrowInPromiseConstructor, ThrowInInitialSuspend,
               ThrowInGetReturnObject, ThrowInUnhandledException, RethrowInUnhandledException> {
  Promise() {
    if constexpr (ThrowInPromiseConstructor) {
      throw 1;
    }
  }

  Task get_return_object() {
    if constexpr (ThrowInGetReturnObject) {
      throw 1;
    }

    return Task{*this};
  }

  std::suspend_never initial_suspend() const {
    if constexpr (ThrowInInitialSuspend) {
      throw 1;
    }

    return {};
  }

  std::suspend_never final_suspend() const noexcept { return {}; }

  void return_void() {}

  void unhandled_exception() {
    if constexpr (ThrowInUnhandledException) {
      throw 1;
    } else if constexpr (RethrowInUnhandledException) {
      throw;
    }
  }

  Task *return_val;
};

struct Evil {
  ~Evil() noexcept(false) {
    throw 42;
  }
};

Task<int> returnOne() { co_return 1; }

namespace function {

namespace coreturn {

Task<int> a_ShouldNotDiag(const int a, const int b) {
  if (b == 0)
    throw b;

  co_return a / b;
}

Task<int> b_ShouldNotDiag(const int a, const int b) noexcept {
  if (b == 0)
    throw b;

  co_return a / b;
}

Task<int> c_ShouldNotDiag(const int a, const int b) {
  if (b == 0)
    throw Evil{};

  co_return a / b;
}

Task<int> c_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: an exception may be thrown in function 'c_ShouldDiag' which should not throw exceptions
  if (b == 0)
    throw Evil{};

  co_return a / b;
}

Task<int, true> d_ShouldNotDiag(const int a, const int b) {
  co_return a / b;
}

Task<int, true> d_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: an exception may be thrown in function 'd_ShouldDiag' which should not throw exceptions
  co_return a / b;
}

Task<int, false, true> e_ShouldNotDiag(const int a, const int b) {
  co_return a / b;
}

Task<int, false, true> e_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: an exception may be thrown in function 'e_ShouldDiag' which should not throw exceptions
  co_return a / b;
}

Task<int, false, false, true> f_ShouldNotDiag(const int a, const int b) {
  co_return a / b;
}

Task<int, false, false, true> f_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: an exception may be thrown in function 'f_ShouldDiag' which should not throw exceptions
  co_return a / b;
}

Task<int, false, false, false, true> g_ShouldNotDiag(const int a, const int b) {
  co_return a / b;
}

Task<int, false, false, false, true> g_ShouldDiag(const int a,
                                                  const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-2]]:38: warning: an exception may be thrown in function 'g_ShouldDiag' which should not throw exceptions
  co_return a / b;
}

Task<int, false, false, false, false, true> h_ShouldNotDiag(const int a,
                                                            const int b) {
  co_return a / b;
}

Task<int, false, false, false, false, true> h_ShouldDiag(const int a,
                                                         const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-2]]:45: warning: an exception may be thrown in function 'h_ShouldDiag' which should not throw exceptions
  co_return a / b;
}

Task<int, false, false, false, false, false, true>
i_ShouldNotDiag(const int a, const int b) {
  co_return a / b;
}

Task<int, false, false, false, false, false, true>
i_ShouldNotDiagNoexcept(const int a, const int b) noexcept {
  co_return a / b;
}

Task<int, false, false, false, false, false, true>
j_ShouldNotDiag(const int a, const int b) {
  if (b == 0)
    throw b;

  co_return a / b;
}

Task<int, false, false, false, false, false, true>
j_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: an exception may be thrown in function 'j_ShouldDiag' which should not throw exceptions
  if (b == 0)
    throw b;

  co_return a / b;
}

} // namespace coreturn

namespace coyield {

Task<int> a_ShouldNotDiag(const int a, const int b) {
  if (b == 0)
    throw b;

  co_yield a / b;
}

Task<int> b_ShouldNotDiag(const int a, const int b) noexcept {
  if (b == 0)
    throw b;

  co_yield a / b;
}

Task<int> c_ShouldNotDiag(const int a, const int b) {
  if (b == 0)
    throw Evil{};

  co_yield a / b;
}

Task<int> c_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: an exception may be thrown in function 'c_ShouldDiag' which should not throw exceptions
  if (b == 0)
    throw Evil{};

  co_yield a / b;
}

Task<int, true> d_ShouldNotDiag(const int a, const int b) {
  co_yield a / b;
}

Task<int, true> d_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: an exception may be thrown in function 'd_ShouldDiag' which should not throw exceptions
  co_yield a / b;
}

Task<int, false, true> e_ShouldNotDiag(const int a, const int b) {
  co_yield a / b;
}

Task<int, false, true> e_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: an exception may be thrown in function 'e_ShouldDiag' which should not throw exceptions
  co_yield a / b;
}

Task<int, false, false, true> f_ShouldNotDiag(const int a, const int b) {
  co_yield a / b;
}

Task<int, false, false, true> f_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: an exception may be thrown in function 'f_ShouldDiag' which should not throw exceptions
  co_yield a / b;
}

Task<int, false, false, false, true> g_ShouldNotDiag(const int a, const int b) {
  co_yield a / b;
}

Task<int, false, false, false, true> g_ShouldDiag(const int a,
                                                  const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-2]]:38: warning: an exception may be thrown in function 'g_ShouldDiag' which should not throw exceptions
  co_yield a / b;
}

Task<int, false, false, false, false, true> h_ShouldNotDiag(const int a,
                                                            const int b) {
  co_yield a / b;
}

Task<int, false, false, false, false, true> h_ShouldDiag(const int a,
                                                         const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-2]]:45: warning: an exception may be thrown in function 'h_ShouldDiag' which should not throw exceptions
  co_yield a / b;
}

Task<int, false, false, false, false, false, true>
i_ShouldNotDiag(const int a, const int b) {
  co_yield a / b;
}

Task<int, false, false, false, false, false, true>
i_ShouldNotDiagNoexcept(const int a, const int b) noexcept {
  co_yield a / b;
}

Task<int, false, false, false, false, false, true>
j_ShouldNotDiag(const int a, const int b) {
  if (b == 0)
    throw b;

  co_yield a / b;
}

Task<int, false, false, false, false, false, true>
j_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: an exception may be thrown in function 'j_ShouldDiag' which should not throw exceptions
  if (b == 0)
    throw b;

  co_yield a / b;
}

} // namespace coyield

namespace coawait {

Task<void> a_ShouldNotDiag(const int a, const int b) {
  if (b == 0)
    throw b;

  co_await returnOne();
}

Task<void> b_ShouldNotDiag(const int a, const int b) noexcept {
  if (b == 0)
    throw b;

  co_await returnOne();
}

Task<void> c_ShouldNotDiag(const int a, const int b) {
  if (b == 0)
    throw Evil{};

  co_await returnOne();
}

Task<void> c_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: an exception may be thrown in function 'c_ShouldDiag' which should not throw exceptions
  if (b == 0)
    throw Evil{};

  co_await returnOne();
}

Task<void, true> d_ShouldNotDiag(const int a, const int b) {
  co_await returnOne();
}

Task<void, true> d_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: an exception may be thrown in function 'd_ShouldDiag' which should not throw exceptions
  co_await returnOne();
}

Task<void, false, true> e_ShouldNotDiag(const int a, const int b) {
  co_await returnOne();
}

Task<void, false, true> e_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: an exception may be thrown in function 'e_ShouldDiag' which should not throw exceptions
  co_await returnOne();
}

Task<void, false, false, true> f_ShouldNotDiag(const int a, const int b) {
  co_await returnOne();
}

Task<void, false, false, true> f_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: an exception may be thrown in function 'f_ShouldDiag' which should not throw exceptions
  co_await returnOne();
}

Task<void, false, false, false, true> g_ShouldNotDiag(const int a,
                                                      const int b) {
  co_await returnOne();
}

Task<void, false, false, false, true> g_ShouldDiag(const int a,
                                                   const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-2]]:39: warning: an exception may be thrown in function 'g_ShouldDiag' which should not throw exceptions
  co_await returnOne();
}

Task<void, false, false, false, false, true> h_ShouldNotDiag(const int a,
                                                             const int b) {
  co_await returnOne();
}

Task<void, false, false, false, false, true>
h_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: an exception may be thrown in function 'h_ShouldDiag' which should not throw exceptions
  co_await returnOne();
}

Task<int, false, false, false, false, false, true>
i_ShouldNotDiag(const int a, const int b) {
  co_await returnOne();
}

Task<int, false, false, false, false, false, true>
i_ShouldNotDiagNoexcept(const int a, const int b) noexcept {
  co_await returnOne();
}

Task<int, false, false, false, false, false, true>
j_ShouldNotDiag(const int a, const int b) {
  co_await returnOne();
  if (b == 0)
    throw b;
}

Task<int, false, false, false, false, false, true>
j_ShouldDiag(const int a, const int b) noexcept {
  // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: an exception may be thrown in function 'j_ShouldDiag' which should not throw exceptions
  co_await returnOne();
  if (b == 0)
    throw b;
}

} // namespace coawait

} // namespace function

namespace lambda {

namespace coreturn {

const auto a_ShouldNotDiag = [](const int a, const int b) -> Task<int> {
  if (b == 0)
    throw b;

  co_return a / b;
};

const auto b_ShouldNotDiag = [](const int a,
                                const int b) noexcept -> Task<int> {
  if (b == 0)
    throw b;

  co_return a / b;
};

const auto c_ShouldNotDiag = [](const int a, const int b) -> Task<int> {
  if (b == 0)
    throw Evil{};

  co_return a / b;
};

const auto c_ShouldDiag = [](const int a, const int b) noexcept -> Task<int> {
  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  if (b == 0)
    throw Evil{};

  co_return a / b;
};

const auto d_ShouldNotDiag = [](const int a, const int b) -> Task<int, true> {
  co_return a / b;
};

const auto d_ShouldDiag = [](const int a,
                             const int b) noexcept -> Task<int, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_return a / b;
};

const auto e_ShouldNotDiag = [](const int a,
                                const int b) -> Task<int, false, true> {
  co_return a / b;
};

const auto e_ShouldDiag = [](const int a,
                             const int b) noexcept -> Task<int, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_return a / b;
};

const auto f_ShouldNotDiag = [](const int a,
                                const int b) -> Task<int, false, false, true> {
  co_return a / b;
};

const auto f_ShouldDiag =
    [](const int a, const int b) noexcept -> Task<int, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_return a / b;
};

const auto g_ShouldNotDiag =
    [](const int a, const int b) -> Task<int, false, false, false, true> {
  co_return a / b;
};

const auto g_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_return a / b;
};

const auto h_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<int, false, false, false, false, true> {
  co_return a / b;
};

const auto h_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_return a / b;
};

const auto i_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<int, false, false, false, false, false, true> {
  co_return a / b;
};

const auto i_ShouldNotDiagNoexcept =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, false, false, true> {
  co_return a / b;
};

const auto j_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<int, false, false, false, false, false, true> {
  if (b == 0)
    throw b;

  co_return a / b;
};

const auto j_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  if (b == 0)
    throw b;

  co_return a / b;
};

} // namespace coreturn

namespace coyield {

const auto a_ShouldNotDiag = [](const int a, const int b) -> Task<int> {
  if (b == 0)
    throw b;

  co_yield a / b;
};

const auto b_ShouldNotDiag = [](const int a,
                                const int b) noexcept -> Task<int> {
  if (b == 0)
    throw b;

  co_yield a / b;
};

const auto c_ShouldNotDiag = [](const int a, const int b) -> Task<int> {
  if (b == 0)
    throw Evil{};

  co_yield a / b;
};

const auto c_ShouldDiag = [](const int a, const int b) noexcept -> Task<int> {
  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  if (b == 0)
    throw Evil{};

  co_yield a / b;
};

const auto d_ShouldNotDiag = [](const int a, const int b) -> Task<int, true> {
  co_yield a / b;
};

const auto d_ShouldDiag = [](const int a,
                             const int b) noexcept -> Task<int, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_yield a / b;
};

const auto e_ShouldNotDiag = [](const int a,
                                const int b) -> Task<int, false, true> {
  co_yield a / b;
};

const auto e_ShouldDiag = [](const int a,
                             const int b) noexcept -> Task<int, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_yield a / b;
};

const auto f_ShouldNotDiag = [](const int a,
                                const int b) -> Task<int, false, false, true> {
  co_yield a / b;
};

const auto f_ShouldDiag =
    [](const int a, const int b) noexcept -> Task<int, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_yield a / b;
};

const auto g_ShouldNotDiag =
    [](const int a, const int b) -> Task<int, false, false, false, true> {
  co_yield a / b;
};

const auto g_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_yield a / b;
};

const auto h_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<int, false, false, false, false, true> {
  co_yield a / b;
};

const auto h_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_yield a / b;
};

const auto i_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<int, false, false, false, false, false, true> {
  co_yield a / b;
};

const auto i_ShouldNotDiagNoexcept =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, false, false, true> {
  co_yield a / b;
};

const auto j_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<int, false, false, false, false, false, true> {
  if (b == 0)
    throw b;

  co_yield a / b;
};

const auto j_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  if (b == 0)
    throw b;

  co_yield a / b;
};

} // namespace coyield

namespace coawait {

const auto a_ShouldNotDiag = [](const int a, const int b) -> Task<void> {
  if (b == 0)
    throw b;

  co_await returnOne();
};

const auto b_ShouldNotDiag = [](const int a,
                                const int b) noexcept -> Task<void> {
  if (b == 0)
    throw b;

  co_await returnOne();
};

const auto c_ShouldNotDiag = [](const int a, const int b) -> Task<void> {
  if (b == 0)
    throw Evil{};

  co_await returnOne();
};

const auto c_ShouldDiag = [](const int a, const int b) noexcept -> Task<void> {
  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  if (b == 0)
    throw Evil{};

  co_await returnOne();
};

const auto d_ShouldNotDiag = [](const int a, const int b) -> Task<void, true> {
  co_await returnOne();
};

const auto d_ShouldDiag = [](const int a,
                             const int b) noexcept -> Task<void, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_await returnOne();
};

const auto e_ShouldNotDiag = [](const int a,
                                const int b) -> Task<void, false, true> {
  co_await returnOne();
};

const auto e_ShouldDiag = [](const int a,
                             const int b) noexcept -> Task<void, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:27: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_await returnOne();
};

const auto f_ShouldNotDiag = [](const int a,
                                const int b) -> Task<void, false, false, true> {
  co_await returnOne();
};

const auto f_ShouldDiag =
    [](const int a, const int b) noexcept -> Task<void, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_await returnOne();
};

const auto g_ShouldNotDiag =
    [](const int a, const int b) -> Task<void, false, false, false, true> {
  co_await returnOne();
};

const auto g_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<void, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_await returnOne();
};

const auto h_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<void, false, false, false, false, true> {
  co_await returnOne();
};

const auto h_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<void, false, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_await returnOne();
};

const auto i_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<int, false, false, false, false, false, true> {
  co_await returnOne();
};

const auto i_ShouldNotDiagNoexcept =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, false, false, true> {
  co_await returnOne();
};

const auto j_ShouldNotDiag =
    [](const int a,
       const int b) -> Task<int, false, false, false, false, false, true> {
  co_await returnOne();
  if (b == 0)
    throw b;
};

const auto j_ShouldDiag =
    [](const int a,
       const int b) noexcept -> Task<int, false, false, false, false, false, true> {
  // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: an exception may be thrown in function 'operator()' which should not throw exceptions
  co_await returnOne();
  if (b == 0)
    throw b;
};

} // namespace coawait

} // namespace lambda