}];
}

def MlrtAsyncHandleType : DialectType<Mlrt_Dialect,
    CPred<"$_self.isa<::mlrt::compiler::AsyncHandleType>()">, "!mlrt.async_handle type">,
    BuildableType<"$_builder.getType<::mlrt::compiler::AsyncHandleType>()"> {
  let description = [{
    `!mlrt.async_handle type` represents a C++ mlrt::AsyncHandle.
  }];
}

  func.return %t2, %t3 : !tf_mlrt.tensor, !tf_mlrt.tensor
}

// -----

// CHECK-LABEL: @main
// CHECK-SAME: ([[f0:%.*]]: !mlrt.async_handle, [[f1:%.*]]: !mlrt.async_handle, [[f2:%.*]]: !mlrt.async_handle)
func.func @main(%f0: !mlrt.async_handle, %f1: !mlrt.async_handle, %f2: !mlrt.async_handle) -> () {
  // CHECK-NEXT: mlrt.await_all_handle [[f0]], [[f1]], [[f2]]
  // CHECK-NOT: mlrt.await_handle
  // CHECK-NEXT: return

  if (parser.parseKeyword(&keyword)) return mlir::Type();

  if (keyword == "future") return FutureType::get(getContext());
  if (keyword == "promise") return PromiseType::get(getContext());
  if (keyword == "async_handle") return AsyncHandleType::get(getContext());

  parser.emitError(parser.getNameLoc(), "unknown type: ") << keyword;
  return mlir::Type();
}

// Print a type registered to this dialect.

};

// The MLIR type represents a C++ mlrt::AsyncHandle.
class AsyncHandleType : public mlir::Type::TypeBase<AsyncHandleType, mlir::Type,
                                                    mlir::TypeStorage> {
 public:
  using Base::Base;
  static constexpr mlir::StringLiteral name = "mlrt.compiler.async_handle";
};

}  // namespace compiler
}  // namespace mlrt

    {callee = @main_stream_0} :
    (tensor<i32>, !mlrt.promise) -> !mlrt.async_handle
  // CHECK: [[handle_1:%.*]] = mlrt.async([[input1]], [[promises]]#1, [[promises]]#2)
  // CHECK-SAME: callee = @main_stream_1
  %handle_1 = mlrt.async(%input1, %promise_c, %promise_d)
    {callee = @main_stream_1} :
    (tensor<i32>, !mlrt.promise, !mlrt.promise) -> !mlrt.async_handle

// CHECK: [[ASYNC_HANDLE_2:%.*]] = mlrt.async([[x]], [[FUTURE]]#1, [[CONTROL_PROMISE]])
// CHECK-SAME: callee = @main_stream_{{[0-9]*}}
// CHECK: [[y:%.*]] = "tf_mlrt.tf_await"([[FUTURE]]#2)
// CHECK: [[RES:%.*]] = "tf.AddV2"([[x]], [[y]])
// CHECK: mlrt.await_handle [[ASYNC_HANDLE_0]]
// CHECK-NEXT: mlrt.await_handle [[ASYNC_HANDLE_1]]
// CHECK-NEXT: mlrt.await_handle [[ASYNC_HANDLE_2]]
// CHECK-NEXT: return [[RES]]

// arbitrary number of Records without either blocking or allocation.
type asyncHandler struct {
	ringBuffer [100]slog.Record
	next       int
}

func newAsyncHandler() *asyncHandler {
	return &asyncHandler{}
}

func (*asyncHandler) Enabled(context.Context, slog.Level) bool { return true }

func (h *asyncHandler) Handle(_ context.Context, r slog.Record) error {
	h.ringBuffer[h.next] = r.Clone()

     */
    public boolean isAsyncHandled () {
        return this.asyncHandled;
    }


    /**
     * @param asyncHandled
     *            the asyncHandled to set
     */
    public void setAsyncHandled ( boolean asyncHandled ) {
        this.asyncHandled = asyncHandled;
    }


    /**
     * {@inheritDoc}
     *