// RUN:   mlir-opt %s -async-to-async-runtime                                  \
// RUN:               -async-runtime-ref-counting                              \
// RUN:               -async-runtime-ref-counting-opt                          \
// RUN:               -convert-async-to-llvm                                   \
// RUN:               -convert-linalg-to-loops                                 \
// RUN:               -convert-scf-to-std                                      \
// RUN:               -convert-linalg-to-llvm                                  \
// RUN:               -convert-vector-to-llvm                                  \
// RUN:               -convert-arith-to-llvm                                   \
// RUN:               -convert-std-to-llvm                                     \
// RUN:               -reconcile-unrealized-casts                              \
// RUN: | mlir-cpu-runner                                                      \
// RUN:     -e main -entry-point-result=void -O0                               \
// RUN:     -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext  \
// RUN:     -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext    \
// RUN:     -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext   \
// RUN: | FileCheck %s --dump-input=always

func @main() {
  %false = arith.constant 0 : i1

  // ------------------------------------------------------------------------ //
  // Check that simple async region completes without errors.
  // ------------------------------------------------------------------------ //
  %token0 = async.execute {
    async.yield
  }
  async.runtime.await %token0 : !async.token

  // CHECK: 0
  %err0 = async.runtime.is_error %token0 : !async.token
  vector.print %err0 : i1

  // ------------------------------------------------------------------------ //
  // Check that assertion in the async region converted to async error.
  // ------------------------------------------------------------------------ //
  %token1 = async.execute {
    assert %false, "error"
    async.yield
  }
  async.runtime.await %token1 : !async.token

  // CHECK: 1
  %err1 = async.runtime.is_error %token1 : !async.token
  vector.print %err1 : i1

  // ------------------------------------------------------------------------ //
  // Check error propagation from the nested region.
  // ------------------------------------------------------------------------ //
  %token2 = async.execute {
    %token = async.execute {
      assert %false, "error"
      async.yield
    }
    async.await %token : !async.token
    async.yield
  }
  async.runtime.await %token2 : !async.token

  // CHECK: 1
  %err2 = async.runtime.is_error %token2 : !async.token
  vector.print %err2 : i1

  // ------------------------------------------------------------------------ //
  // Check error propagation from the nested region with async values.
  // ------------------------------------------------------------------------ //
  %token3, %value3 = async.execute -> !async.value<f32> {
    %token, %value = async.execute -> !async.value<f32> {
      assert %false, "error"
      %0 = arith.constant 123.45 : f32
      async.yield %0 : f32
    }
    %ret = async.await %value : !async.value<f32>
    async.yield %ret : f32
  }
  async.runtime.await %token3 : !async.token
  async.runtime.await %value3 : !async.value<f32>

  // CHECK: 1
  // CHECK: 1
  %err3_0 = async.runtime.is_error %token3 : !async.token
  %err3_1 = async.runtime.is_error %value3 : !async.value<f32>
  vector.print %err3_0 : i1
  vector.print %err3_1 : i1

  // ------------------------------------------------------------------------ //
  // Check error propagation from a token to the group.
  // ------------------------------------------------------------------------ //

  %c2 = arith.constant 2 : index
  %group0 = async.create_group %c2 : !async.group

  %token4 = async.execute {
    async.yield
  }

  %token5 = async.execute {
    assert %false, "error"
    async.yield
  }

  %idx0 = async.add_to_group %token4, %group0 : !async.token
  %idx1 = async.add_to_group %token5, %group0 : !async.token

  async.runtime.await %group0 : !async.group

  // CHECK: 1
  %err4 = async.runtime.is_error %group0 : !async.group
  vector.print %err4 : i1

  return
}